Add ByteTrack MOT algorithm

README.md

@@ -5,6 +5,7 @@
 [![CodeQL](https://github.com/Smorodov/Multitarget-tracker/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/Smorodov/Multitarget-tracker/actions/workflows/codeql-analysis.yml)
 
 ## Latest Features
+- Add ByteTrack MOT algorithm based on [Vertical-Beach/ByteTrack-cpp](https://github.com/Vertical-Beach/ByteTrack-cpp)
 - Big code cleanup from old style algorithms and detectors: some bgfg detectors, some VOT trackes, Face and Pedestrin detectors, Darknet based backend for old YOLO etc
 - YOLOv13 detector works with TensorRT! Export pre-trained PyTorch models [here (iMoonLab/yolov13)](https://github.com/iMoonLab/yolov13) to ONNX format and run Multitarget-tracker with `-e=3` example
 - Instance segmentation model from RF-DETR detector works with TensorRT! Export pre-trained PyTorch models [here (roboflow/rf-detr)](https://github.com/roboflow/rf-detr) to ONNX format and run Multitarget-tracker with `-e=3` example

async_detector/AsyncDetector.cpp

@@ -336,7 +336,7 @@ void AsyncDetector::CaptureThread(std::string fileName, int startFrame, int* fra
 	++frameInd;
 
     std::thread thDetection(DetectThread, detectorConfig, firstFrame, framesQue, stopFlag);
-    std::thread thTracking(TrackingThread, trackerSettings, framesQue, stopFlag);
+    std::thread thTracking(TrackingThread, trackerSettings, framesQue, *fps, stopFlag);
 
     // Capture frame
     for (; !(*stopFlag);)
@@ -406,9 +406,9 @@ void AsyncDetector::DetectThread(const config_t& config, cv::Mat firstFrame, Fra
 /// \brief AsyncDetector::TrackingThread
 /// \param
 ///
-void AsyncDetector::TrackingThread(const TrackerSettings& settings, FramesQueue* framesQue, bool* stopFlag)
+void AsyncDetector::TrackingThread(const TrackerSettings& settings, FramesQueue* framesQue, float fps, bool* stopFlag)
 {
-    std::unique_ptr<BaseTracker> tracker = BaseTracker::CreateTracker(settings);
+    std::unique_ptr<BaseTracker> tracker = BaseTracker::CreateTracker(settings, fps);
 
     for (; !(*stopFlag);)
     {

async_detector/AsyncDetector.h

@@ -10,7 +10,7 @@
 #include <condition_variable>
 
 #include "BaseDetector.h"
-#include "Ctracker.h"
+#include "BaseTracker.h"
 
 #include "spdlog/spdlog.h"
 #include "spdlog/async.h"
@@ -81,7 +81,7 @@ class AsyncDetector
 
     static void CaptureThread(std::string fileName, int startFrame, int* framesCount, float* fps, FramesQueue* framesQue, bool* stopFlag);
     static void DetectThread(const config_t& config, cv::Mat firstFrame, FramesQueue* framesQue, bool* stopFlag);
-	static void TrackingThread(const TrackerSettings& settings, FramesQueue* framesQue, bool* stopFlag);
+	static void TrackingThread(const TrackerSettings& settings, FramesQueue* framesQue, float fps, bool* stopFlag);
 
     std::shared_ptr<spdlog::sinks::stdout_color_sink_mt> m_consoleSink;
     std::shared_ptr<spdlog::sinks::rotating_file_sink_mt> m_fileSink;

data/settings_yolov13s.ini

@@ -52,6 +52,11 @@ inference_precision = FP16
 
 [tracking]
 
+#-----------------------------
+# UniversalTracker = 0
+# ByteTrack = 1
+tracker_type = 1
+
 #-----------------------------
 # DistCenters = 0   // Euclidean distance between centers, pixels
 # DistRects = 1     // Euclidean distance between bounding rectangles, pixels
@@ -134,3 +139,10 @@ min_static_time = 5
 max_static_time = 25
 # Speed in pixels. If speed of object is more that this value than object is non static
 max_speed_for_static = 10
+
+#-----------------------------
+# Settings only for m_tracker = tracking::ByteTrack
+bytetrack_track_buffer = 30
+bytetrack_track_thresh = 0.5
+bytetrack_high_thresh = 0.5
+bytetrack_match_thresh = 0.8

example/CarsCounting.cpp

@@ -218,7 +218,7 @@ bool CarsCounting::InitTracker(cv::UMat frame)
         settings.m_maxTraceLength = 4.;          // Maximum trace length
     }
 
-    m_tracker = BaseTracker::CreateTracker(settings);
+    m_tracker = BaseTracker::CreateTracker(settings, m_fps);
 
     ReadGeobindings(frame.size());
     return true;

example/MotionDetectorExample.h

@@ -128,7 +128,7 @@ class MotionDetectorExample final : public VideoExample
 			}
 		}
 
-        m_tracker = BaseTracker::CreateTracker(m_trackerSettings);
+        m_tracker = BaseTracker::CreateTracker(m_trackerSettings, m_fps);
         return true;
     }
 

example/MouseExample.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Ctracker.h"
+#include "BaseTracker.h"
 
 #include <iostream>
 #include <vector>
@@ -57,7 +57,7 @@ void MouseTracking(cv::CommandLineParser parser)
 	settings.m_maximumAllowedLostTime = 1.;
 	settings.m_maxTraceLength = 1.;
 
-	std::unique_ptr<BaseTracker> tracker = BaseTracker::CreateTracker(settings);
+	std::unique_ptr<BaseTracker> tracker = BaseTracker::CreateTracker(settings, 30.f);
 
 	track_t alpha = 0;
 	cv::RNG rng;

example/VideoExample.h

@@ -9,7 +9,7 @@
 #include <atomic>
 
 #include "BaseDetector.h"
-#include "Ctracker.h"
+#include "BaseTracker.h"
 #include "FileLogger.h"
 #include "cvatAnnotationsGenerator.h"
 

example/examples.h

@@ -140,7 +140,7 @@ class OpenCVDNNExample final : public VideoExample
 			m_trackerSettings.m_maximumAllowedLostTime = 2.; // Maximum allowed skipped frames
 			m_trackerSettings.m_maxTraceLength = 2.;         // Maximum trace length
 		}
-		m_tracker = BaseTracker::CreateTracker(m_trackerSettings);
+		m_tracker = BaseTracker::CreateTracker(m_trackerSettings, m_fps);
 		return true;
 	}
 
@@ -481,7 +481,7 @@ class ONNXTensorRTExample final : public VideoExample
         //m_trackerSettings.AddNearTypes(TypeConverter::Str2Type("person"), TypeConverter::Str2Type("bicycle"), true);
         //m_trackerSettings.AddNearTypes(TypeConverter::Str2Type("person"), TypeConverter::Str2Type("motorbike"), true);
 
-		m_tracker = BaseTracker::CreateTracker(m_trackerSettings);
+		m_tracker = BaseTracker::CreateTracker(m_trackerSettings, m_fps);
 
 		return true;
 	}

src/Tracker/Ctracker.cpp → src/Tracker/BaseTracker.cpp

@@ -1,5 +1,6 @@
 #include <fstream>
-#include "Ctracker.h"
+#include "BaseTracker.h"
+#include "byte_track/BYTETracker.h"
 #include "ShortPathCalculator.h"
 #include "EmbeddingsCalculator.hpp"
 #include "track.h"
@@ -20,7 +21,6 @@ class CTracker final : public BaseTracker
 
     void Update(const regions_t& regions, cv::UMat currFrame, time_point_t frameTime) override;
 
-    size_t GetTracksCount() const override;
     void GetTracks(std::vector<TrackingObject>& tracks) const override;
     void GetRemovedTracks(std::vector<track_id_t>& trackIDs) const override;
 
@@ -84,15 +84,6 @@ CTracker::CTracker(const TrackerSettings& settings)
     }
 }
 
-///
-/// \brief GetTracksCount
-/// \return
-///
-size_t CTracker::GetTracksCount() const
-{
-    return m_tracks.size();
-}
-
 ///
 /// \brief GetTracks
 /// \return
@@ -676,7 +667,18 @@ track_t CTracker::GetEllipseDist(const CTrack& trackRef, const CRegion& reg)
 ///
 /// BaseTracker::CreateTracker
 ///
-std::unique_ptr<BaseTracker> BaseTracker::CreateTracker(const TrackerSettings& settings)
+std::unique_ptr<BaseTracker> BaseTracker::CreateTracker(const TrackerSettings& settings, float fps)
 {
-    return std::make_unique<CTracker>(settings);
+    switch (settings.m_tracker)
+    {
+    case tracking::UniversalTracker:
+        return std::make_unique<CTracker>(settings);
+
+    case tracking::ByteTrack:
+        return std::make_unique<byte_track::BYTETracker>((fps > 1.f) ? cvRound(fps) : 30, settings.m_byteTrackSettings.m_trackBuffer,
+            settings.m_byteTrackSettings.m_trackThresh, settings.m_byteTrackSettings.m_highThresh, settings.m_byteTrackSettings.m_matchThresh);
+
+    default:
+        return std::make_unique<CTracker>(settings);
+    }
 }

src/Tracker/Ctracker.h → src/Tracker/BaseTracker.h

@@ -27,7 +27,7 @@ class BaseTracker
         cv::UMat frame = currFrame.getUMat(cv::ACCESS_READ);
         Update(regions, frame, frameTime);
     }
-    virtual size_t GetTracksCount() const = 0;
+
     virtual void GetTracks(std::vector<TrackingObject>& tracks) const = 0;
     virtual std::vector<TrackingObject> GetTracksCopy() const
     {
@@ -37,5 +37,5 @@ class BaseTracker
     }
     virtual void GetRemovedTracks(std::vector<track_id_t>& trackIDs) const = 0;
 
-    static std::unique_ptr<BaseTracker> CreateTracker(const TrackerSettings& settings);
+    static std::unique_ptr<BaseTracker> CreateTracker(const TrackerSettings& settings, float fps);
 };

src/Tracker/CMakeLists.txt

@@ -9,24 +9,32 @@ set(main_sources
              ../common/object_types.cpp)
 
 set(tracker_sources
-             Ctracker.cpp
+             BaseTracker.cpp
              track.cpp
              Kalman.cpp
              TrackerSettings.cpp
              ShortPathCalculator.cpp
              HungarianAlg/HungarianAlg.cpp
-             LAPJV_algorithm/lap.cpp)
+             LAPJV_algorithm/lap.cpp
+             byte_track/BYTETracker.cpp
+             byte_track/KalmanFilter.cpp
+             byte_track/lapjv.cpp
+             byte_track/STrack.cpp)
 
 set(tracker_headers
-             Ctracker.h
+             BaseTracker.h
              ShortPathCalculator.h
              track.h
              trajectory.h
              Kalman.h
              TrackerSettings.h
              HungarianAlg/HungarianAlg.h
              LAPJV_algorithm/lap.h
-             EmbeddingsCalculator.hpp)
+             EmbeddingsCalculator.hpp
+             byte_track/BYTETracker.h
+             byte_track/KalmanFilter.h
+             byte_track/lapjv.h
+             byte_track/STrack.h)
 
 SOURCE_GROUP("Src" FILES ${main_sources})
 SOURCE_GROUP("Tracker" FILES ${tracker_sources} ${tracker_headers})

src/Tracker/TrackerSettings.cpp

@@ -20,6 +20,12 @@ bool ParseTrackerSettings(const std::string& settingsFile, TrackerSettings& trac
         trackerSettings = TrackerSettings();
 
         // Read tracking settings
+        auto trackerType = reader.GetInteger("tracking", "tracker_type", -1);
+        if (trackerType == (int)tracking::ByteTrack)
+            trackerSettings.m_tracker = tracking::ByteTrack;
+        else
+            trackerSettings.m_tracker = tracking::UniversalTracker;
+
         auto distType = reader.GetInteger("tracking", "distance_type", -1);
         if (distType >= 0 && distType < (int)tracking::DistsCount)
             trackerSettings.SetDistance((tracking::DistType)distType);
@@ -53,6 +59,10 @@ bool ParseTrackerSettings(const std::string& settingsFile, TrackerSettings& trac
         trackerSettings.m_maxStaticTime = reader.GetInteger("tracking", "max_static_time", 25);
         trackerSettings.m_maxSpeedForStatic = reader.GetInteger("tracking", "max_speed_for_static", 10);
 
+        trackerSettings.m_byteTrackSettings.m_trackBuffer = reader.GetInteger("tracking", "bytetrack_track_buffer", 30);
+        trackerSettings.m_byteTrackSettings.m_trackThresh = reader.GetReal("tracking", "bytetrack_track_thresh", 0.5);
+        trackerSettings.m_byteTrackSettings.m_highThresh = reader.GetReal("tracking", "bytetrack_high_thresh", 0.5);
+        trackerSettings.m_byteTrackSettings.m_matchThresh = reader.GetReal("tracking", "bytetrack_match_thresh", 0.8);
 
         // Read detection settings
         trackerSettings.m_nnWeights = reader.GetString("detection", "nn_weights", "data/yolov4-tiny_best.weights");

src/Tracker/TrackerSettings.h

@@ -13,6 +13,9 @@ struct TrackerSettings
     ///
     /// Tracker settings
     ///
+    /// 
+
+    tracking::TrackerTemplate m_tracker = tracking::UniversalTracker;
 
     tracking::KalmanType m_kalmanType = tracking::KalmanLinear;
     tracking::FilterGoal m_filterGoal = tracking::FilterCenter;
@@ -98,6 +101,19 @@ struct TrackerSettings
     ///
     std::map<objtype_t, std::set<objtype_t>> m_nearTypes;
 
+	///
+    /// \brief struct ByteTrackSettings
+    /// Settings only for m_tracker = tracking::ByteTrack
+    ///
+	struct ByteTrackSettings
+	{
+		int m_trackBuffer = 30;
+		float m_trackThresh = 0.5f;
+		float m_highThresh = 0.5f;
+		float m_matchThresh = 0.8f;
+	};
+    ByteTrackSettings m_byteTrackSettings;
+
 
     ///
     /// Detector settings