Multitarget-tracker/src/Tracker/ShortPathCalculator.h at master · fjfabz/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
#pragma once
#include "defines.h"
#include "HungarianAlg/HungarianAlg.h"

///
/// \brief The SPSettings struct
///
struct SPSettings
{
    track_t m_distThres = 0.8f;
    size_t m_maxHistory = 10;
};

///
/// \brief The ShortPathCalculator class
///
class ShortPathCalculator
{
public:
    ShortPathCalculator(const SPSettings& settings)
        : m_settings(settings)
    {
    }
    virtual ~ShortPathCalculator()
    {
    }

    virtual void Solve(const distMatrix_t& costMatrix, size_t N, size_t M, assignments_t& assignment, track_t maxCost) = 0;
protected:
    SPSettings m_settings;
};

///
/// \brief The SPHungrian class
///
class SPHungrian : public ShortPathCalculator
{
public:
    SPHungrian(const SPSettings& settings)
        : ShortPathCalculator(settings)
    {
    }

    void Solve(const distMatrix_t& costMatrix, size_t N, size_t M, assignments_t& assignment, track_t /*maxCost*/)
    {
        m_solver.Solve(costMatrix, N, M, assignment, AssignmentProblemSolver::optimal);
    }

private:
    AssignmentProblemSolver m_solver;
};

///
/// \brief The SPBipart class
///
class SPBipart : public ShortPathCalculator
{
public:
    SPBipart(const SPSettings& settings)
        : ShortPathCalculator(settings)
    {
    }

    void Solve(const distMatrix_t& costMatrix, size_t N, size_t M, assignments_t& assignment, track_t maxCost);
};

///
/// \brief The SPmuSSP class
///
class SPmuSSP : public ShortPathCalculator
{
public:
    SPmuSSP(const SPSettings& settings)
        : ShortPathCalculator(settings)
    {
    }

    void Solve(const distMatrix_t& costMatrix, size_t N, size_t M, assignments_t& assignment, track_t maxCost);

private:

    ///
    /// \brief The Node struct
    ///
    struct Node
    {
        std::vector<std::pair<size_t, track_t>> m_arcs;
        void Add(size_t ind, track_t weight)
        {
            m_arcs.emplace_back(ind, weight);
        }
        void Resize(size_t count)
        {
            m_arcs.resize(count);
        }
    };
    ///
    /// \brief The Layer struct
    ///
    struct Layer
    {
        std::vector<Node> m_nodes;
        size_t m_arcsCount = 0;

        void Resize(size_t count)
        {
            m_nodes.resize(count);
        }
        const Node& Back() const
        {
            return m_nodes.back();
        }
        Node& Back()
        {
            return m_nodes.back();
        }
        size_t Size() const
        {
            return m_nodes.size();
        }
        const Node& operator[](size_t ind) const
        {
            return m_nodes[ind];
        }
        Node& operator[](size_t ind)
        {
            return m_nodes[ind];
        }
    };

    std::deque<Layer> m_detects;
};