Multitarget-tracker/Tracker/Ctracker.h at save_data · HenryFOCUS/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
#pragma once
#include <iostream>
#include <vector>
#include <memory>
#include <array>
#include <chrono>

#include "defines.h"
#include "track.h"
#include "LocalTracker.h"

// ----------------------------------------------------------------------
#define SAVE_TRAJECTORIES 1

#if SAVE_TRAJECTORIES
#include <fstream>

class SaveTrajectories
{
public:
    SaveTrajectories()
        : m_sizeWrited(false), m_delim(",")
    {

    }
    ~SaveTrajectories()
    {
    }

    bool Open(std::string fileName)
    {
        if (fileName.length() > 0)
        {
            m_file.open(fileName.c_str(), std::ios_base::out | std::ios_base::trunc);
        }
        if (m_file.is_open())
        {
            m_sizeWrited = false;
        }
        return m_file.is_open();
    }

    bool WriteFrameSize(int frame_width, int frame_height)
    {
        if (m_file.is_open() && !m_sizeWrited)
        {
            m_file << frame_width << m_delim << frame_height << std::endl;
            m_sizeWrited = true;
        }
        return m_sizeWrited;
    }

    bool NewTrack(const CTrack& track)
    {
        if (m_file.is_open())
        {
            int type = 2;

            if (track.IsRobust(25, 0.7, cv::Size2f(0.9f, 4.0f)))
            {
                for (size_t j = 0; j < track.m_trace.size(); ++j)
                {
                    const TrajectoryPoint& pt = track.m_trace.at(j);

                    m_file << pt.m_frameInd << m_delim
                           << track.m_trackID << m_delim
                           << type << m_delim
                           << pt.m_prediction.x << m_delim
                           << pt.m_prediction.y << m_delim
                           << (static_cast<track_t>(pt.m_size.width) / static_cast<track_t>(pt.m_size.height)) << m_delim
                           << pt.m_size.width << m_delim
                           << pt.m_size.height << m_delim
                           << pt.m_time << m_delim
                           << (j + 1) << std::endl;
                }
            }
            return true;
        }
        return false;
    }

private:
    std::ofstream m_file;
    bool m_sizeWrited;
    std::string m_delim;
};
#endif

// --------------------------------------------------------------------------
class CTracker
{
public:
    CTracker(bool useLocalTracking,
             tracking::DistType distType,
             tracking::KalmanType kalmanType,
             tracking::FilterGoal filterGoal,
             tracking::LostTrackType useExternalTrackerForLostObjects,
             tracking::MatchType matchType,
             track_t dt_,
             track_t accelNoiseMag_,
             track_t dist_thres_ = 60,
             size_t maximum_allowed_skipped_frames_ = 10,
             size_t max_trace_length_ = 10);
	~CTracker(void);

    tracks_t tracks;
    void Update(const std::vector<Point_t>& detections, const regions_t& regions, cv::Mat grayFrame, int frameInd = 0);

#if SAVE_TRAJECTORIES
    void WriteAllTracks();
#endif

private:
    // Use local tracking for regions between two frames
    bool m_useLocalTracking;

    tracking::DistType m_distType;
    tracking::KalmanType m_kalmanType;
    tracking::FilterGoal m_filterGoal;
    tracking::LostTrackType m_useExternalTrackerForLostObjects;
    tracking::MatchType m_matchType;

	// Шаг времени опроса фильтра
	track_t dt;

	track_t accelNoiseMag;

	// Порог расстояния. Если точки находятся дуг от друга на расстоянии,
	// превышающем этот порог, то эта пара не рассматривается в задаче о назначениях.
	track_t dist_thres;
	// Максимальное количество кадров которое трек сохраняется не получая данных о измерений.
    size_t maximum_allowed_skipped_frames;
	// Максимальная длина следа
    size_t max_trace_length;

	size_t NextTrackID;

    LocalTracker m_localTracker;

    cv::Mat m_prevFrame;

#if SAVE_TRAJECTORIES
    SaveTrajectories m_saveTraj;
#endif
};