Multitarget-tracker/src/Tracker/track.h at master · yxu13/Multitarget-tracker · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#pragma once
#include <iostream>
#include <vector>
#include <deque>
#include <memory>
#include <array>

#ifdef USE_OCV_KCF
#include <opencv2/tracking.hpp>
#endif

#include "defines.h"
#include "trajectory.h"
#include "object_types.h"
#include "Kalman.h"
#include "VOTTracker.hpp"

///
/// \brief The RegionEmbedding struct
///
struct RegionEmbedding
{
    cv::Mat m_hist;
    cv::Mat m_embedding;
    double m_embDot = 0.;
};

///
/// \brief The CTrack class
///
class CTrack
{
public:
    CTrack(const CRegion& region,
           tracking::KalmanType kalmanType,
           track_t deltaTime,
           track_t accelNoiseMag,
           bool useAcceleration,
           size_t trackID,
           bool filterObjectSize,
           tracking::LostTrackType externalTrackerForLost);

    CTrack(const CRegion& region,
           const RegionEmbedding& regionEmbedding,
           tracking::KalmanType kalmanType,
           track_t deltaTime,
           track_t accelNoiseMag,
           bool useAcceleration,
           size_t trackID,
           bool filterObjectSize,
           tracking::LostTrackType externalTrackerForLost);

    ///
    /// \brief CalcDistCenter
    /// Euclidean distance from 0 to 1  between objects centres on two N and N+1 frames
    /// \param reg
    /// \return
    ///
    track_t CalcDistCenter(const CRegion& reg) const;
    ///
    /// \brief CalcDistRect
    /// Euclidean distance from 0 to 1 between object contours on two N and N+1 frames
    /// \param reg
    /// \return
    ///
    track_t CalcDistRect(const CRegion& reg) const;
    ///
    /// \brief CalcDistJaccard
    /// Jaccard distance from 0 to 1 between object bounding rectangles on two N and N+1 frames
    /// \param reg
    /// \return
    ///
    track_t CalcDistJaccard(const CRegion& reg) const;
	///
	/// \brief CalcDistHist
	/// Distance from 0 to 1 between objects histogramms on two N and N+1 frames
	/// \param embedding
	/// \return
	///
    track_t CalcDistHist(const RegionEmbedding& embedding) const;
	///
	/// \brief CalcCosine
	/// Distance from 0 to 1 between objects embeddings on two N and N+1 frames
	/// \param embedding
	/// \return
	///
	track_t CalcCosine(const RegionEmbedding& embedding) const;

	cv::RotatedRect CalcPredictionEllipse(cv::Size_<track_t> minRadius) const;
	///
	/// \brief IsInsideArea
	/// Test point inside in prediction area: prediction area + object velocity
	/// \param pt
	/// \param minVal
	/// \return
	///
	track_t IsInsideArea(const Point_t& pt, const cv::RotatedRect& rrect) const;
    track_t WidthDist(const CRegion& reg) const;
    track_t HeightDist(const CRegion& reg) const;

    void Update(const CRegion& region, bool dataCorrect, size_t max_trace_length, cv::UMat prevFrame, cv::UMat currFrame, int trajLen, int maxSpeedForStatic);
    void Update(const CRegion& region, const RegionEmbedding& regionEmbedding, bool dataCorrect, size_t max_trace_length, cv::UMat prevFrame, cv::UMat currFrame, int trajLen, int maxSpeedForStatic);

    bool IsStatic() const;
    bool IsStaticTimeout(int framesTime) const;
    bool IsOutOfTheFrame() const;

    cv::RotatedRect GetLastRect() const;

    const Point_t& AveragePoint() const;
    Point_t& AveragePoint();
    const CRegion& LastRegion() const;
    size_t SkippedFrames() const;
    size_t& SkippedFrames();

    TrackingObject ConstructObject() const;

private:
    TKalmanFilter m_kalman;
    CRegion m_lastRegion;
    Trace m_trace;
    cv::RotatedRect m_predictionRect;
    Point_t m_predictionPoint;

    size_t m_trackID = 0;
    size_t m_skippedFrames = 0;

    tracking::LostTrackType m_externalTrackerForLost = tracking::TrackNone;
#ifdef USE_OCV_KCF
    cv::Ptr<cv::Tracker> m_tracker;
#endif
    std::unique_ptr<VOTTracker> m_VOTTracker;

    ///
    void RectUpdate(const CRegion& region, bool dataCorrect, cv::UMat prevFrame, cv::UMat currFrame);

    ///
    void CreateExternalTracker(int channels);

    ///
    void PointUpdate(const Point_t& pt, const cv::Size& newObjSize, bool dataCorrect, const cv::Size& frameSize);

    RegionEmbedding m_regionEmbedding;

    ///
    bool CheckStatic(int trajLen, cv::UMat currFrame, const CRegion& region, int maxSpeedForStatic);
    cv::UMat m_staticFrame;
    cv::Rect m_staticRect;
    int m_staticFrames = 0;
    bool m_isStatic = false;

    bool m_filterObjectSize = false;
    bool m_outOfTheFrame = false;
};

typedef std::vector<std::unique_ptr<CTrack>> tracks_t;