[MOT] add cpplint & refine format in pptracking (#4501)

.pre-commit-config.yaml

@@ -25,3 +25,20 @@
         files: \.(md|yml)$
     -   id: remove-tabs
         files: \.(md|yml)$
+-   repo: local
+    hooks:
+    -   id: clang-format-with-version-check
+        name: clang-format
+        description: Format files with ClangFormat.
+        entry: bash ./.travis/codestyle/clang_format.hook -i
+        language: system
+        files: \.(c|cc|cxx|cpp|cu|h|hpp|hxx|proto)$
+
+-   repo: local
+    hooks:
+    -   id: cpplint-cpp-source
+        name: cpplint
+        description: Check C++ code style using cpplint.py.
+        entry: bash ./.travis/codestyle/cpplint_pre_commit.hook
+        language: system
+        files: \.(c|cc|cxx|cpp|cu|h|hpp|hxx)$

.travis/codestyle/clang_format.hook

+#!/bin/bash
+set -e
+
+readonly VERSION="3.8"
+
+version=$(clang-format -version)
+
+if ! [[ $version == *"$VERSION"* ]]; then
+    echo "clang-format version check failed."
+    echo "a version contains '$VERSION' is needed, but get '$version'"
+    echo "you can install the right version, and make an soft-link to '\$PATH' env"
+    exit -1
+fi
+
+clang-format $@

.travis/codestyle/cpplint_pre_commit.hook

+#!/bin/bash
+
+TOTAL_ERRORS=0
+if [[ ! $TRAVIS_BRANCH ]]; then
+  # install cpplint on local machine.
+  if [[ ! $(which cpplint) ]]; then
+    pip install cpplint
+  fi
+  # diff files on local machine. 
+  files=$(git diff --cached --name-status | awk '$1 != "D" {print $2}')
+else
+  # diff files between PR and latest commit on Travis CI. 
+  branch_ref=$(git rev-parse "$TRAVIS_BRANCH")
+  head_ref=$(git rev-parse HEAD)
+  files=$(git diff --name-status $branch_ref $head_ref | awk '$1 != "D" {print $2}')
+fi
+# The trick to remove deleted files: https://stackoverflow.com/a/2413151
+for file in $files; do
+    if [[ $file =~ ^(patches/.*) ]]; then
+        continue;
+    else
+        cpplint --filter=-readability/fn_size,-build/include_what_you_use,-build/c++11 $file;
+        TOTAL_ERRORS=$(expr $TOTAL_ERRORS + $?);
+    fi
+done
+
+exit $TOTAL_ERRORS

deploy/pptracking/include/config_parser.h

@@ -15,9 +15,9 @@
 #pragma once
 
 #include <iostream>
-#include <vector>
-#include <string>
 #include <map>
+#include <string>
+#include <vector>
 
 #include "yaml-cpp/yaml.h"
 
@@ -47,8 +47,7 @@ class ConfigPaser {
       mode_ = config["mode"].as<std::string>();
     } else {
       std::cerr << "Please set mode, "
-                << "support value : fluid/trt_fp16/trt_fp32."
-                << std::endl;
+                << "support value : fluid/trt_fp16/trt_fp32." << std::endl;
       return false;
     }
 
@@ -136,4 +135,3 @@ class ConfigPaser {
 };
 
 }  // namespace PaddleDetection
-

deploy/pptracking/include/jde_predictor.h

@@ -14,37 +14,37 @@
 
 #pragma once
 
-#include <string>
-#include <vector>
+#include <ctime>
 #include <memory>
+#include <string>
 #include <utility>
-#include <ctime>
+#include <vector>
 
 #include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
 
 #include "paddle_inference_api.h"  // NOLINT
 
-#include "include/preprocess_op.h"
 #include "include/config_parser.h"
+#include "include/preprocess_op.h"
 #include "include/utils.h"
 
-using namespace paddle_infer;
+using namespace paddle_infer;  // NOLINT
 
 namespace PaddleDetection {
 
 class JDEPredictor {
  public:
-  explicit JDEPredictor(const std::string& device="CPU",
-                         const std::string& model_dir="",
-                         const double threshold=-1.,
-                         const std::string& run_mode="fluid",
-                         const int gpu_id=0,
-                         const bool use_mkldnn=false,
-                         const int cpu_threads=1,
-                         bool trt_calib_mode=false,
-                         const int min_box_area=200) {
+  explicit JDEPredictor(const std::string& device = "CPU",
+                        const std::string& model_dir = "",
+                        const double threshold = -1.,
+                        const std::string& run_mode = "fluid",
+                        const int gpu_id = 0,
+                        const bool use_mkldnn = false,
+                        const int cpu_threads = 1,
+                        bool trt_calib_mode = false,
+                        const int min_box_area = 200) {
     this->device_ = device;
     this->gpu_id_ = gpu_id;
     this->use_mkldnn_ = use_mkldnn;
@@ -60,8 +60,7 @@ class JDEPredictor {
   }
 
   // Load Paddle inference model
-  void LoadModel(
-    const std::string& model_dir,
+  void LoadModel(const std::string& model_dir,
                  const std::string& run_mode = "fluid");
 
   // Run predictor
@@ -82,9 +81,7 @@ class JDEPredictor {
   // Preprocess image and copy data to input buffer
   void Preprocess(const cv::Mat& image_mat);
   // Postprocess result
-  void Postprocess(
-      const cv::Mat dets, const cv::Mat emb,
-      MOTResult* result);
+  void Postprocess(const cv::Mat dets, const cv::Mat emb, MOTResult* result);
 
   std::shared_ptr<Predictor> predictor_;
   Preprocessor preprocessor_;

deploy/pptracking/include/lapjv.h

@@ -17,9 +17,8 @@
 // Ths copyright of gatagat/lap is as follows:
 // MIT License
 
-#ifndef LAPJV_H
-#define LAPJV_H
-
+#ifndef DEPLOY_PPTRACKING_INCLUDE_LAPJV_H_
+#define DEPLOY_PPTRACKING_INCLUDE_LAPJV_H_
 #define LARGE 1000000
 
 #if !defined TRUE
@@ -29,9 +28,21 @@
 #define FALSE 0
 #endif
 
-#define NEW(x, t, n) if ((x = (t *)malloc(sizeof(t) * (n))) == 0) {return -1;}
-#define FREE(x) if (x != 0) { free(x); x = 0; }
-#define SWAP_INDICES(a, b) { int_t _temp_index = a; a = b; b = _temp_index; }
+#define NEW(x, t, n)                                               \
+  if ((x = reinterpret_cast<t *>(malloc(sizeof(t) * (n)))) == 0) { \
+    return -1;                                                     \
+  }
+#define FREE(x) \
+  if (x != 0) { \
+    free(x);    \
+    x = 0;      \
+  }
+#define SWAP_INDICES(a, b) \
+  {                        \
+    int_t _temp_index = a; \
+    a = b;                 \
+    b = _temp_index;       \
+  }
 #include <opencv2/opencv.hpp>
 
 namespace PaddleDetection {
@@ -42,11 +53,12 @@ typedef double cost_t;
 typedef char boolean;
 typedef enum fp_t { FP_1 = 1, FP_2 = 2, FP_DYNAMIC = 3 } fp_t;
 
-int lapjv_internal(
-    const cv::Mat &cost, const bool extend_cost, const float cost_limit,
-    int *x, int *y);
+int lapjv_internal(const cv::Mat &cost,
+                   const bool extend_cost,
+                   const float cost_limit,
+                   int *x,
+                   int *y);
 
 }  // namespace PaddleDetection
 
-#endif // LAPJV_H
-
+#endif  // DEPLOY_PPTRACKING_INCLUDE_LAPJV_H_

deploy/pptracking/include/pipeline.h

@@ -12,16 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#ifndef DEPLOY_PPTRACKING_INCLUDE_PIPELINE_H_
+#define DEPLOY_PPTRACKING_INCLUDE_PIPELINE_H_
+
 #include <glog/logging.h>
 
+#include <math.h>
+#include <sys/types.h>
+#include <algorithm>
 #include <iostream>
+#include <numeric>
 #include <string>
 #include <vector>
-#include <numeric>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <math.h>
-#include <algorithm>
 
 #ifdef _WIN32
 #include <direct.h>
@@ -41,16 +43,16 @@ class Pipeline {
   explicit Pipeline(const std::string& device,
                     const double threshold,
                     const std::string& output_dir,
-                  const std::string& run_mode="fluid",
-                  const int gpu_id=0,
-                  const bool use_mkldnn=false,
-                  const int cpu_threads=1,
-                  const bool trt_calib_mode=false,
-                  const bool count=false,
-                  const bool save_result=false,
-                  const std::string& scene="pedestrian",
-                  const bool tiny_obj=false,
-                  const bool is_mtmct=false) {
+                    const std::string& run_mode = "fluid",
+                    const int gpu_id = 0,
+                    const bool use_mkldnn = false,
+                    const int cpu_threads = 1,
+                    const bool trt_calib_mode = false,
+                    const bool count = false,
+                    const bool save_result = false,
+                    const std::string& scene = "pedestrian",
+                    const bool tiny_obj = false,
+                    const bool is_mtmct = false) {
     std::vector<std::string> input;
     this->input_ = input;
     this->device_ = device;
@@ -67,10 +69,8 @@ class Pipeline {
     InitPredictor();
   }
 
-
-
   // Set input, it must execute before Run()
-  void SetInput(std::string& input_video);
+  void SetInput(const std::string& input_video);
   void ClearInput();
 
   // Run pipeline in video
@@ -79,16 +79,23 @@ class Pipeline {
   void PredictMTMCT(const std::vector<std::string> video_inputs);
 
   // Run pipeline in stream
-  void RunMOTStream(const cv::Mat img, const int frame_id, cv::Mat& out_img, std::vector<std::string>& records, std::vector<int>& count_list, std::vector<int>& in_count_list, std::vector<int>& out_count_list);
-  void RunMTMCTStream(const std::vector<cv::Mat> imgs, std::vector<std::string>& records);
-
-  void PrintBenchmarkLog(std::vector<double> det_time, int img_num);
+  void RunMOTStream(const cv::Mat img,
+                    const int frame_id,
+                    cv::Mat out_img,
+                    std::vector<std::string>* records,
+                    std::vector<int>* count_list,
+                    std::vector<int>* in_count_list,
+                    std::vector<int>* out_count_list);
+  void RunMTMCTStream(const std::vector<cv::Mat> imgs,
+                      std::vector<std::string>* records);
+
+  void PrintBenchmarkLog(const std::vector<double> det_time, const int img_num);
 
  private:
   // Select model according to scenes, it must execute before Run()
-  void SelectModel(const std::string& scene="pedestrian",
-                   const bool tiny_obj=false,
-                   const bool is_mtmct=false);
+  void SelectModel(const std::string& scene = "pedestrian",
+                   const bool tiny_obj = false,
+                   const bool is_mtmct = false);
   void InitPredictor();
 
   std::shared_ptr<PaddleDetection::JDEPredictor> jde_sct_;
@@ -112,3 +119,5 @@ class Pipeline {
 };
 
 }  // namespace PaddleDetection
+
+#endif  // DEPLOY_PPTRACKING_INCLUDE_PIPELINE_H_

deploy/pptracking/include/postprocess.h

@@ -14,15 +14,15 @@
 
 #pragma once
 
-#include <string>
-#include <vector>
+#include <ctime>
 #include <memory>
+#include <string>
 #include <utility>
-#include <ctime>
+#include <vector>
 
 #include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
 
 #include "include/utils.h"
 
@@ -34,15 +34,19 @@ cv::Scalar GetColor(int idx);
 // Visualize Tracking Results
 cv::Mat VisualizeTrackResult(const cv::Mat& img,
                              const MOTResult& results,
-                     const float fps, const int frame_id);
+                             const float fps,
+                             const int frame_id);
 
 // Pedestrian/Vehicle Counting
-void FlowStatistic(const MOTResult& results, const int frame_id,
+void FlowStatistic(const MOTResult& results,
+                   const int frame_id,
                    std::vector<int>* count_list,
                    std::vector<int>* in_count_list,
                    std::vector<int>* out_count_list);
 
 // Save Tracking Results
-void SaveMOTResult(const MOTResult& results, const int frame_id, std::vector<std::string>& records);
+void SaveMOTResult(const MOTResult& results,
+                   const int frame_id,
+                   std::vector<std::string>* records);
 
 }  // namespace PaddleDetection

deploy/pptracking/include/preprocess_op.h

@@ -17,16 +17,16 @@
 #include <glog/logging.h>
 #include <yaml-cpp/yaml.h>
 
-#include <vector>
-#include <string>
-#include <utility>
+#include <iostream>
 #include <memory>
+#include <string>
 #include <unordered_map>
-#include <iostream>
+#include <utility>
+#include <vector>
 
 #include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
 
 namespace PaddleDetection {
 
@@ -40,7 +40,7 @@ class ImageBlob {
   // in net data shape(after pad)
   std::vector<float> in_net_shape_;
   // Evaluation image width and height
-  //std::vector<float>  eval_im_size_f_;
+  // std::vector<float>  eval_im_size_f_;
   // Scale factor for image size to origin image size
   std::vector<float> scale_factor_;
 };
@@ -52,7 +52,7 @@ class PreprocessOp {
   virtual void Run(cv::Mat* im, ImageBlob* data) = 0;
 };
 
-class InitInfo : public PreprocessOp{
+class InitInfo : public PreprocessOp {
  public:
   virtual void Init(const YAML::Node& item) {}
   virtual void Run(cv::Mat* im, ImageBlob* data);
@@ -79,7 +79,6 @@ class Permute : public PreprocessOp {
  public:
   virtual void Init(const YAML::Node& item) {}
   virtual void Run(cv::Mat* im, ImageBlob* data);
-
 };
 
 class Resize : public PreprocessOp {
@@ -155,7 +154,8 @@ class Preprocessor {
       // use PadStride instead of PadBatch
       return std::make_shared<PadStride>();
     }
-    std::cerr << "can not find function of OP: " << name << " and return: nullptr" << std::endl;
+    std::cerr << "can not find function of OP: " << name
+              << " and return: nullptr" << std::endl;
     return nullptr;
   }
 
@@ -169,4 +169,3 @@ class Preprocessor {
 };
 
 }  // namespace PaddleDetection
-

deploy/pptracking/include/sde_predictor.h

@@ -14,38 +14,38 @@
 
 #pragma once
 
-#include <string>
-#include <vector>
+#include <ctime>
 #include <memory>
+#include <string>
 #include <utility>
-#include <ctime>
+#include <vector>
 
 #include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
 
 #include "paddle_inference_api.h"  // NOLINT
 
-#include "include/preprocess_op.h"
 #include "include/config_parser.h"
+#include "include/preprocess_op.h"
 #include "include/utils.h"
 
-using namespace paddle_infer;
+using namespace paddle_infer;  // NOLINT
 
 namespace PaddleDetection {
 
 class SDEPredictor {
  public:
   explicit SDEPredictor(const std::string& device,
-                         const std::string& det_model_dir="",
-                         const std::string& reid_model_dir="",
-                         const double threshold=-1.,
-                         const std::string& run_mode="fluid",
-                         const int gpu_id=0,
-                         const bool use_mkldnn=false,
-                         const int cpu_threads=1,
-                         bool trt_calib_mode=false,
-                         const int min_box_area=200) {
+                        const std::string& det_model_dir = "",
+                        const std::string& reid_model_dir = "",
+                        const double threshold = -1.,
+                        const std::string& run_mode = "fluid",
+                        const int gpu_id = 0,
+                        const bool use_mkldnn = false,
+                        const int cpu_threads = 1,
+                        bool trt_calib_mode = false,
+                        const int min_box_area = 200) {
     this->device_ = device;
     this->gpu_id_ = gpu_id;
     this->use_mkldnn_ = use_mkldnn;
@@ -65,8 +65,7 @@ class SDEPredictor {
   }
 
   // Load Paddle inference model
-  void LoadModel(
-    const std::string& det_model_dir,
+  void LoadModel(const std::string& det_model_dir,
                  const std::string& reid_model_dir,
                  const std::string& run_mode = "fluid");
 
@@ -88,9 +87,7 @@ class SDEPredictor {
   // Preprocess image and copy data to input buffer
   void Preprocess(const cv::Mat& image_mat);
   // Postprocess result
-  void Postprocess(
-      const cv::Mat dets, const cv::Mat emb,
-      MOTResult* result);
+  void Postprocess(const cv::Mat dets, const cv::Mat emb, MOTResult* result);
 
   std::shared_ptr<Predictor> det_predictor_;
   std::shared_ptr<Predictor> reid_predictor_;

deploy/pptracking/include/tracker.h

@@ -21,35 +21,44 @@
 
 #include <map>
 #include <vector>
-#include <opencv2/opencv.hpp>
 
-#include "trajectory.h"
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include "include/trajectory.h"
 
 namespace PaddleDetection {
 
 typedef std::map<int, int> Match;
 typedef std::map<int, int>::iterator MatchIterator;
 
-struct Track
-{
+struct Track {
   int id;
   float score;
   cv::Vec4f ltrb;
 };
 
-class JDETracker
-{
-public:
+class JDETracker {
+ public:
   static JDETracker *instance(void);
-    virtual bool update(const cv::Mat &dets, const cv::Mat &emb, std::vector<Track> &tracks);
-private:
+  virtual bool update(const cv::Mat &dets,
+                      const cv::Mat &emb,
+                      std::vector<Track> *tracks);
+
+ private:
   JDETracker(void);
   virtual ~JDETracker(void) {}
   cv::Mat motion_distance(const TrajectoryPtrPool &a, const TrajectoryPool &b);
-    void linear_assignment(const cv::Mat &cost, float cost_limit, Match &matches,
-        std::vector<int> &mismatch_row, std::vector<int> &mismatch_col);
-    void remove_duplicate_trajectory(TrajectoryPool &a, TrajectoryPool &b, float iou_thresh=0.15f);
-private:
+  void linear_assignment(const cv::Mat &cost,
+                         float cost_limit,
+                         Match *matches,
+                         std::vector<int> *mismatch_row,
+                         std::vector<int> *mismatch_col);
+  void remove_duplicate_trajectory(TrajectoryPool *a,
+                                   TrajectoryPool *b,
+                                   float iou_thresh = 0.15f);
+
+ private:
   static JDETracker *me;
   int timestamp;
   TrajectoryPool tracked_trajectories;

deploy/pptracking/include/trajectory.h

@@ -20,88 +20,104 @@
 #pragma once
 
 #include <vector>
-#include <opencv2/opencv.hpp>
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include "opencv2/video/tracking.hpp"
 
 namespace PaddleDetection {
 
-typedef enum
-{
-    New = 0,
-    Tracked = 1,
-    Lost = 2,
-    Removed = 3
-} TrajectoryState;
+typedef enum { New = 0, Tracked = 1, Lost = 2, Removed = 3 } TrajectoryState;
 
 class Trajectory;
 typedef std::vector<Trajectory> TrajectoryPool;
 typedef std::vector<Trajectory>::iterator TrajectoryPoolIterator;
-typedef std::vector<Trajectory *>TrajectoryPtrPool;
+typedef std::vector<Trajectory *> TrajectoryPtrPool;
 typedef std::vector<Trajectory *>::iterator TrajectoryPtrPoolIterator;
 
-class TKalmanFilter : public cv::KalmanFilter
-{
-public:
+class TKalmanFilter : public cv::KalmanFilter {
+ public:
   TKalmanFilter(void);
   virtual ~TKalmanFilter(void) {}
   virtual void init(const cv::Mat &measurement);
   virtual const cv::Mat &predict();
   virtual const cv::Mat &correct(const cv::Mat &measurement);
-    virtual void project(cv::Mat &mean, cv::Mat &covariance) const;
-private:
+  virtual void project(cv::Mat *mean, cv::Mat *covariance) const;
+
+ private:
   float std_weight_position;
   float std_weight_velocity;
 };
 
-inline TKalmanFilter::TKalmanFilter(void) : cv::KalmanFilter(8, 4)
-{
+inline TKalmanFilter::TKalmanFilter(void) : cv::KalmanFilter(8, 4) {
   cv::KalmanFilter::transitionMatrix = cv::Mat::eye(8, 8, CV_32F);
   for (int i = 0; i < 4; ++i)
     cv::KalmanFilter::transitionMatrix.at<float>(i, i + 4) = 1;
   cv::KalmanFilter::measurementMatrix = cv::Mat::eye(4, 8, CV_32F);
-    std_weight_position = 1/20.f;
-    std_weight_velocity = 1/160.f;
+  std_weight_position = 1 / 20.f;
+  std_weight_velocity = 1 / 160.f;
 }
 
-class Trajectory : public TKalmanFilter
-{
-public:
+class Trajectory : public TKalmanFilter {
+ public:
   Trajectory();
-    Trajectory(cv::Vec4f &ltrb, float score, const cv::Mat &embedding);
+  Trajectory(const cv::Vec4f &ltrb, float score, const cv::Mat &embedding);
   Trajectory(const Trajectory &other);
   Trajectory &operator=(const Trajectory &rhs);
-    virtual ~Trajectory(void) {};
+  virtual ~Trajectory(void) {}
 
   static int next_id();
   virtual const cv::Mat &predict(void);
-    virtual void update(Trajectory &traj, int timestamp, bool update_embedding=true);
+  virtual void update(Trajectory *traj,
+                      int timestamp,
+                      bool update_embedding = true);
   virtual void activate(int timestamp);
-    virtual void reactivate(Trajectory &traj, int timestamp, bool newid=false);
+  virtual void reactivate(Trajectory *traj, int timestamp, bool newid = false);
   virtual void mark_lost(void);
   virtual void mark_removed(void);
 
-    friend TrajectoryPool operator+(const TrajectoryPool &a, const TrajectoryPool &b);
-    friend TrajectoryPool operator+(const TrajectoryPool &a, const TrajectoryPtrPool &b);
-    friend TrajectoryPool &operator+=(TrajectoryPool &a, const TrajectoryPtrPool &b);
-    friend TrajectoryPool operator-(const TrajectoryPool &a, const TrajectoryPool &b);
-    friend TrajectoryPool &operator-=(TrajectoryPool &a, const TrajectoryPool &b);
-    friend TrajectoryPtrPool operator+(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
-    friend TrajectoryPtrPool operator+(const TrajectoryPtrPool &a, TrajectoryPool &b);
-    friend TrajectoryPtrPool operator-(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
-
-    friend cv::Mat embedding_distance(const TrajectoryPool &a, const TrajectoryPool &b);
-    friend cv::Mat embedding_distance(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
-    friend cv::Mat embedding_distance(const TrajectoryPtrPool &a, const TrajectoryPool &b);
-
-    friend cv::Mat mahalanobis_distance(const TrajectoryPool &a, const TrajectoryPool &b);
-    friend cv::Mat mahalanobis_distance(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
-    friend cv::Mat mahalanobis_distance(const TrajectoryPtrPool &a, const TrajectoryPool &b);
+  friend TrajectoryPool operator+(const TrajectoryPool &a,
+                                  const TrajectoryPool &b);
+  friend TrajectoryPool operator+(const TrajectoryPool &a,
+                                  const TrajectoryPtrPool &b);
+  friend TrajectoryPool &operator+=(TrajectoryPool &a,  // NOLINT
+                                    const TrajectoryPtrPool &b);
+  friend TrajectoryPool operator-(const TrajectoryPool &a,
+                                  const TrajectoryPool &b);
+  friend TrajectoryPool &operator-=(TrajectoryPool &a,  // NOLINT
+                                    const TrajectoryPool &b);
+  friend TrajectoryPtrPool operator+(const TrajectoryPtrPool &a,
+                                     const TrajectoryPtrPool &b);
+  friend TrajectoryPtrPool operator+(const TrajectoryPtrPool &a,
+                                     TrajectoryPool *b);
+  friend TrajectoryPtrPool operator-(const TrajectoryPtrPool &a,
+                                     const TrajectoryPtrPool &b);
+
+  friend cv::Mat embedding_distance(const TrajectoryPool &a,
+                                    const TrajectoryPool &b);
+  friend cv::Mat embedding_distance(const TrajectoryPtrPool &a,
+                                    const TrajectoryPtrPool &b);
+  friend cv::Mat embedding_distance(const TrajectoryPtrPool &a,
+                                    const TrajectoryPool &b);
+
+  friend cv::Mat mahalanobis_distance(const TrajectoryPool &a,
+                                      const TrajectoryPool &b);
+  friend cv::Mat mahalanobis_distance(const TrajectoryPtrPool &a,
+                                      const TrajectoryPtrPool &b);
+  friend cv::Mat mahalanobis_distance(const TrajectoryPtrPool &a,
+                                      const TrajectoryPool &b);
 
   friend cv::Mat iou_distance(const TrajectoryPool &a, const TrajectoryPool &b);
-    friend cv::Mat iou_distance(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
-    friend cv::Mat iou_distance(const TrajectoryPtrPool &a, const TrajectoryPool &b);
-private:   
+  friend cv::Mat iou_distance(const TrajectoryPtrPool &a,
+                              const TrajectoryPtrPool &b);
+  friend cv::Mat iou_distance(const TrajectoryPtrPool &a,
+                              const TrajectoryPool &b);
+
+ private:
   void update_embedding(const cv::Mat &embedding);
-public:
+
+ public:
   TrajectoryState state;
   cv::Vec4f ltrb;
   cv::Mat smooth_embedding;
@@ -110,7 +126,8 @@ public:
   int timestamp;
   int starttime;
   float score;
-private:
+
+ private:
   static int count;
   cv::Vec4f xyah;
   cv::Mat current_embedding;
@@ -118,8 +135,7 @@ private:
   int length;
 };
 
-inline cv::Vec4f ltrb2xyah(cv::Vec4f &ltrb)
-{
+inline cv::Vec4f ltrb2xyah(const cv::Vec4f &ltrb) {
   cv::Vec4f xyah;
   xyah[0] = (ltrb[0] + ltrb[2]) * 0.5f;
   xyah[1] = (ltrb[1] + ltrb[3]) * 0.5f;
@@ -128,25 +144,46 @@ inline cv::Vec4f ltrb2xyah(cv::Vec4f &ltrb)
   return xyah;
 }
 
-inline Trajectory::Trajectory() :
-    state(New), ltrb(cv::Vec4f()), smooth_embedding(cv::Mat()), id(0),
-    is_activated(false), timestamp(0), starttime(0), score(0), eta(0.9), length(0)
-{
-}
-
-inline Trajectory::Trajectory(cv::Vec4f &ltrb_, float score_, const cv::Mat &embedding) :
-    state(New), ltrb(ltrb_), smooth_embedding(cv::Mat()), id(0),
-    is_activated(false), timestamp(0), starttime(0), score(score_), eta(0.9), length(0)
-{
+inline Trajectory::Trajectory()
+    : state(New),
+      ltrb(cv::Vec4f()),
+      smooth_embedding(cv::Mat()),
+      id(0),
+      is_activated(false),
+      timestamp(0),
+      starttime(0),
+      score(0),
+      eta(0.9),
+      length(0) {}
+
+inline Trajectory::Trajectory(const cv::Vec4f &ltrb_,
+                              float score_,
+                              const cv::Mat &embedding)
+    : state(New),
+      ltrb(ltrb_),
+      smooth_embedding(cv::Mat()),
+      id(0),
+      is_activated(false),
+      timestamp(0),
+      starttime(0),
+      score(score_),
+      eta(0.9),
+      length(0) {
   xyah = ltrb2xyah(ltrb);
   update_embedding(embedding);
 }
 
-inline Trajectory::Trajectory(const Trajectory &other):
-    state(other.state), ltrb(other.ltrb), id(other.id), is_activated(other.is_activated),
-    timestamp(other.timestamp), starttime(other.starttime), xyah(other.xyah),
-    score(other.score), eta(other.eta), length(other.length)
-{    
+inline Trajectory::Trajectory(const Trajectory &other)
+    : state(other.state),
+      ltrb(other.ltrb),
+      id(other.id),
+      is_activated(other.is_activated),
+      timestamp(other.timestamp),
+      starttime(other.starttime),
+      xyah(other.xyah),
+      score(other.score),
+      eta(other.eta),
+      length(other.length) {
   other.smooth_embedding.copyTo(smooth_embedding);
   other.current_embedding.copyTo(current_embedding);
   // copy state in KalmanFilter
@@ -155,11 +192,9 @@ inline Trajectory::Trajectory(const Trajectory &other):
   other.statePost.copyTo(cv::KalmanFilter::statePost);
   other.errorCovPre.copyTo(cv::KalmanFilter::errorCovPre);
   other.errorCovPost.copyTo(cv::KalmanFilter::errorCovPost);
-    
 }
 
-inline Trajectory &Trajectory::operator=(const Trajectory &rhs)
-{
+inline Trajectory &Trajectory::operator=(const Trajectory &rhs) {
   this->state = rhs.state;
   this->ltrb = rhs.ltrb;
   rhs.smooth_embedding.copyTo(this->smooth_embedding);
@@ -183,20 +218,13 @@ inline Trajectory &Trajectory::operator=(const Trajectory &rhs)
   return *this;
 }
 
-inline int Trajectory::next_id()
-{
+inline int Trajectory::next_id() {
   ++count;
   return count;
 }
 
-inline void Trajectory::mark_lost(void)
-{
-    state = Lost;
-}
+inline void Trajectory::mark_lost(void) { state = Lost; }
 
-inline void Trajectory::mark_removed(void)
-{
-    state = Removed;
-}
+inline void Trajectory::mark_removed(void) { state = Removed; }
 
 }  // namespace PaddleDetection

deploy/pptracking/include/utils.h

@@ -14,27 +14,25 @@
 
 #pragma once
 
-#include <string>
-#include <vector>
-#include <utility>
+#include <algorithm>
 #include <ctime>
 #include <numeric>
-#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "include/tracker.h"
 
 namespace PaddleDetection {
 
-struct Rect
-{
+struct Rect {
   float left;
   float top;
   float right;
   float bottom;
 };
 
-struct MOTTrack
-{
+struct MOTTrack {
   int ids;
   float score;
   Rect rects;

deploy/pptracking/src/jde_predictor.cc

@@ -13,12 +13,11 @@
 // limitations under the License.
 #include <sstream>
 // for setprecision
-#include <iomanip>
 #include <chrono>
+#include <iomanip>
 #include "include/jde_predictor.h"
 
-
-using namespace paddle_infer;
+using namespace paddle_infer;  // NOLINT
 
 namespace PaddleDetection {
 
@@ -37,26 +36,24 @@ void JDEPredictor::LoadModel(const std::string& model_dir,
       auto precision = paddle_infer::Config::Precision::kFloat32;
       if (run_mode == "trt_fp32") {
         precision = paddle_infer::Config::Precision::kFloat32;
-      }
-      else if (run_mode == "trt_fp16") {
+      } else if (run_mode == "trt_fp16") {
         precision = paddle_infer::Config::Precision::kHalf;
-      }
-      else if (run_mode == "trt_int8") {
+      } else if (run_mode == "trt_int8") {
         precision = paddle_infer::Config::Precision::kInt8;
       } else {
-          printf("run_mode should be 'fluid', 'trt_fp32', 'trt_fp16' or 'trt_int8'");
+        printf(
+            "run_mode should be 'fluid', 'trt_fp32', 'trt_fp16' or 'trt_int8'");
       }
       // set tensorrt
-      config.EnableTensorRtEngine(
-          1 << 30,
+      config.EnableTensorRtEngine(1 << 30,
                                   1,
                                   this->min_subgraph_size_,
                                   precision,
                                   false,
                                   this->trt_calib_mode_);
     }
-  } else if (this->device_ == "XPU"){
-    config.EnableXpu(10*1024*1024);
+  } else if (this->device_ == "XPU") {
+    config.EnableXpu(10 * 1024 * 1024);
   } else {
     config.DisableGpu();
     if (this->use_mkldnn_) {
@@ -74,7 +71,9 @@ void JDEPredictor::LoadModel(const std::string& model_dir,
   predictor_ = std::move(CreatePredictor(config));
 }
 
-void FilterDets(const float conf_thresh, const cv::Mat dets, std::vector<int>* index) {
+void FilterDets(const float conf_thresh,
+                const cv::Mat dets,
+                std::vector<int>* index) {
   for (int i = 0; i < dets.rows; ++i) {
     float score = *dets.ptr<float>(i, 4);
     if (score > conf_thresh) {
@@ -89,8 +88,8 @@ void JDEPredictor::Preprocess(const cv::Mat& ori_im) {
   preprocessor_.Run(&im, &inputs_);
 }
 
-void JDEPredictor::Postprocess(
-    const cv::Mat dets, const cv::Mat emb,
+void JDEPredictor::Postprocess(const cv::Mat dets,
+                               const cv::Mat emb,
                                MOTResult* result) {
   result->clear();
   std::vector<Track> tracks;
@@ -101,7 +100,7 @@ void JDEPredictor::Postprocess(
     new_dets.push_back(dets.row(valid[i]));
     new_emb.push_back(emb.row(valid[i]));
   }
-  JDETracker::instance()->update(new_dets, new_emb, tracks);
+  JDETracker::instance()->update(new_dets, new_emb, &tracks);
   if (tracks.size() == 0) {
     MOTTrack mot_track;
     Rect ret = {*dets.ptr<float>(0, 0),
@@ -124,10 +123,8 @@ void JDEPredictor::Postprocess(
         float area = w * h;
         if (area > min_box_area_ && !vertical) {
           MOTTrack mot_track;
-          Rect ret = {titer->ltrb[0],
-                          titer->ltrb[1],
-                          titer->ltrb[2],
-                          titer->ltrb[3]};
+          Rect ret = {
+              titer->ltrb[0], titer->ltrb[1], titer->ltrb[2], titer->ltrb[3]};
           mot_track.rects = ret;
           mot_track.score = titer->score;
           mot_track.ids = titer->id;
@@ -160,8 +157,8 @@ void JDEPredictor::Predict(const std::vector<cv::Mat> imgs,
     scale_factor_all[bs_idx * 2] = inputs_.scale_factor_[0];
     scale_factor_all[bs_idx * 2 + 1] = inputs_.scale_factor_[1];
 
-    // TODO: reduce cost time
-    in_data_all.insert(in_data_all.end(), inputs_.im_data_.begin(), inputs_.im_data_.end());
+    in_data_all.insert(
+        in_data_all.end(), inputs_.im_data_.begin(), inputs_.im_data_.end());
   }
 
   // Prepare input tensor
@@ -224,12 +221,14 @@ void JDEPredictor::Predict(const std::vector<cv::Mat> imgs,
 
   auto postprocess_end = std::chrono::steady_clock::now();
 
-  std::chrono::duration<float> preprocess_diff = preprocess_end - preprocess_start;
-  (*times)[0] += double(preprocess_diff.count() * 1000);
+  std::chrono::duration<float> preprocess_diff =
+      preprocess_end - preprocess_start;
+  (*times)[0] += static_cast<double>(preprocess_diff.count() * 1000);
   std::chrono::duration<float> inference_diff = inference_end - inference_start;
-  (*times)[1] += double(inference_diff.count() * 1000);
-  std::chrono::duration<float> postprocess_diff = postprocess_end - postprocess_start;
-  (*times)[2] += double(postprocess_diff.count() * 1000);
+  (*times)[1] += static_cast<double>(inference_diff.count() * 1000);
+  std::chrono::duration<float> postprocess_diff =
+      postprocess_end - postprocess_start;
+  (*times)[2] += static_cast<double>(postprocess_diff.count() * 1000);
 }
 
 }  // namespace PaddleDetection

deploy/pptracking/src/lapjv.cpp

@@ -27,9 +27,8 @@ namespace PaddleDetection {
 
 /** Column-reduction and reduction transfer for a dense cost matrix.
  */
-int _ccrrt_dense(const int n, float *cost[],
-                     int *free_rows, int *x, int *y, float *v)
-{
+int _ccrrt_dense(
+    const int n, float *cost[], int *free_rows, int *x, int *y, float *v) {
   int n_free_rows;
   bool *unique;
 
@@ -70,7 +69,7 @@ int _ccrrt_dense(const int n, float *cost[],
       const int j = x[i];
       float min = LARGE;
       for (int j2 = 0; j2 < n; j2++) {
-                if (j2 == (int)j) {
+        if (j2 == static_cast<int>(j)) {
           continue;
         }
         const float c = cost[i][j2] - v[j2];
@@ -85,14 +84,15 @@ int _ccrrt_dense(const int n, float *cost[],
   return n_free_rows;
 }
 
-
 /** Augmenting row reduction for a dense cost matrix.
  */
-int _carr_dense(
-    const int n, float *cost[],
+int _carr_dense(const int n,
+                float *cost[],
                 const int n_free_rows,
-    int *free_rows, int *x, int *y, float *v)
-{
+                int *free_rows,
+                int *x,
+                int *y,
+                float *v) {
   int current = 0;
   int new_free_rows = 0;
   int rr_cnt = 0;
@@ -150,11 +150,9 @@ int _carr_dense(
   return new_free_rows;
 }
 
-
 /** Find columns with minimum d[j] and put them on the SCAN list.
  */
-int _find_dense(const int n, int lo, float *d, int *cols, int *y)
-{
+int _find_dense(const int n, int lo, float *d, int *cols, int *y) {
   int hi = lo + 1;
   float mind = d[cols[lo]];
   for (int k = hi; k < n; k++) {
@@ -171,14 +169,17 @@ int _find_dense(const int n, int lo, float *d, int *cols, int *y)
   return hi;
 }
 
-
 // Scan all columns in TODO starting from arbitrary column in SCAN
 // and try to decrease d of the TODO columns using the SCAN column.
-int _scan_dense(const int n, float *cost[],
-                    int *plo, int*phi,
-                    float *d, int *cols, int *pred,
-                    int *y, float *v)
-{
+int _scan_dense(const int n,
+                float *cost[],
+                int *plo,
+                int *phi,
+                float *d,
+                int *cols,
+                int *pred,
+                int *y,
+                float *v) {
   int lo = *plo;
   int hi = *phi;
   float h, cred_ij;
@@ -210,19 +211,19 @@ int _scan_dense(const int n, float *cost[],
   return -1;
 }
 
-
-/** Single iteration of modified Dijkstra shortest path algorithm as explained in the JV paper.
+/** Single iteration of modified Dijkstra shortest path algorithm as explained
+ * in the JV paper.
  *
  * This is a dense matrix version.
  *
  * \return The closest free column index.
  */
-int find_path_dense(
-    const int n, float *cost[],
+int find_path_dense(const int n,
+                    float *cost[],
                     const int start_i,
-    int *y, float *v,
-    int *pred)
-{
+                    int *y,
+                    float *v,
+                    int *pred) {
   int lo = 0, hi = 0;
   int final_j = -1;
   int n_ready = 0;
@@ -250,8 +251,7 @@ int find_path_dense(
       }
     }
     if (final_j == -1) {
-            final_j = _scan_dense(
-                    n, cost, &lo, &hi, d, cols, pred, y, v);
+      final_j = _scan_dense(n, cost, &lo, &hi, d, cols, pred, y, v);
     }
   }
 
@@ -269,14 +269,15 @@ int find_path_dense(
   return final_j;
 }
 
-
 /** Augment for a dense cost matrix.
  */
-int _ca_dense(
-    const int n, float *cost[],
+int _ca_dense(const int n,
+              float *cost[],
               const int n_free_rows,
-    int *free_rows, int *x, int *y, float *v)
-{
+              int *free_rows,
+              int *x,
+              int *y,
+              float *v) {
   int *pred;
 
   NEW(pred, int, n);
@@ -297,19 +298,22 @@ int _ca_dense(
   return 0;
 }
 
-
 /** Solve dense sparse LAP.
  */
-int lapjv_internal(
-    const cv::Mat &cost, const bool extend_cost, const float cost_limit,
-    int *x, int *y ) {
+int lapjv_internal(const cv::Mat &cost,
+                   const bool extend_cost,
+                   const float cost_limit,
+                   int *x,
+                   int *y) {
   int n_rows = cost.rows;
   int n_cols = cost.cols;
   int n;
   if (n_rows == n_cols) {
     n = n_rows;
   } else if (!extend_cost) {
-      throw std::invalid_argument("Square cost array expected. If cost is intentionally non-square, pass extend_cost=True.");
+    throw std::invalid_argument(
+        "Square cost array expected. If cost is intentionally non-square, pass "
+        "extend_cost=True.");
   }
 
   // Get extend cost
@@ -323,7 +327,7 @@ int lapjv_internal(
   } else {
     double max_v;
     minMaxLoc(cost, nullptr, &max_v);
-      expand_value = (float)max_v + 1;
+    expand_value = static_cast<float>(max_v) + 1.;
   }
 
   for (int i = 0; i < n; ++i) {
@@ -376,7 +380,7 @@ int lapjv_internal(
   }
   FREE(cost_ptr);
   if (ret != 0) {
-      if (ret == -1){
+    if (ret == -1) {
       throw "Out of memory.";
     }
     throw "Unknown error (lapjv_internal)";

deploy/pptracking/src/main.cc

@@ -14,44 +14,55 @@
 
 #include <glog/logging.h>
 
+#include <math.h>
+#include <sys/types.h>
+#include <algorithm>
 #include <iostream>
+#include <numeric>
 #include <string>
 #include <vector>
-#include <numeric>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <math.h>
-#include <algorithm>
 
 #ifdef _WIN32
 #include <direct.h>
 #include <io.h>
-#elif LINUX
+#else
 #include <stdarg.h>
 #include <sys/stat.h>
 #endif
 
-#include "include/pipeline.h"
 #include <gflags/gflags.h>
-
+#include "include/pipeline.h"
 
 DEFINE_string(video_file, "", "Path of input video.");
-DEFINE_string(video_other_file, "", "Path of other input video used for MTMCT.");
-DEFINE_string(device, "CPU", "Choose the device you want to run, it can be: CPU/GPU/XPU, default is CPU.");
+DEFINE_string(video_other_file,
+              "",
+              "Path of other input video used for MTMCT.");
+DEFINE_string(device,
+              "CPU",
+              "Choose the device you want to run, it can be: CPU/GPU/XPU, "
+              "default is CPU.");
 DEFINE_double(threshold, 0.5, "Threshold of score.");
 DEFINE_string(output_dir, "output", "Directory of output visualization files.");
-DEFINE_string(run_mode, "fluid", "Mode of running(fluid/trt_fp32/trt_fp16/trt_int8)");
+DEFINE_string(run_mode,
+              "fluid",
+              "Mode of running(fluid/trt_fp32/trt_fp16/trt_int8)");
 DEFINE_int32(gpu_id, 0, "Device id of GPU to execute");
 DEFINE_bool(use_mkldnn, false, "Whether use mkldnn with CPU");
 DEFINE_int32(cpu_threads, 1, "Num of threads with CPU");
-DEFINE_bool(trt_calib_mode, false, "If the model is produced by TRT offline quantitative calibration, trt_calib_mode need to set True");
+DEFINE_bool(trt_calib_mode,
+            false,
+            "If the model is produced by TRT offline quantitative calibration, "
+            "trt_calib_mode need to set True");
 DEFINE_bool(tiny_obj, false, "Whether tracking tiny object");
 DEFINE_bool(count, false, "Whether counting after tracking");
 DEFINE_bool(save_result, false, "Whether saving result after tracking");
-DEFINE_string(scene, "", "scene of tracking system, it can be : pedestrian/vehicle/multiclass");
+DEFINE_string(
+    scene,
+    "",
+    "scene of tracking system, it can be : pedestrian/vehicle/multiclass");
 DEFINE_bool(is_mtmct, false, "Whether use multi-target multi-camera tracking");
 
-static std::string DirName(const std::string &filepath) {
+static std::string DirName(const std::string& filepath) {
   auto pos = filepath.rfind(OS_PATH_SEP);
   if (pos == std::string::npos) {
     return "";
@@ -59,7 +70,7 @@ static std::string DirName(const std::string &filepath) {
   return filepath.substr(0, pos);
 }
 
-static bool PathExists(const std::string& path){
+static bool PathExists(const std::string& path) {
 #ifdef _WIN32
   struct _stat buffer;
   return (_stat(path.c_str(), &buffer) == 0);
@@ -101,13 +112,18 @@ int main(int argc, char** argv) {
               << "-scene=pedestrian/vehicle/multiclass" << std::endl;
     return -1;
   }
-  if (!(FLAGS_run_mode == "fluid" || FLAGS_run_mode == "trt_fp32"
-      || FLAGS_run_mode == "trt_fp16" || FLAGS_run_mode == "trt_int8")) {
-    std::cout << "run_mode should be 'fluid', 'trt_fp32', 'trt_fp16' or 'trt_int8'.";
+  if (!(FLAGS_run_mode == "fluid" || FLAGS_run_mode == "trt_fp32" ||
+        FLAGS_run_mode == "trt_fp16" || FLAGS_run_mode == "trt_int8")) {
+    std::cout
+        << "run_mode should be 'fluid', 'trt_fp32', 'trt_fp16' or 'trt_int8'.";
     return -1;
   }
-  transform(FLAGS_device.begin(),FLAGS_device.end(),FLAGS_device.begin(),::toupper);
-  if (!(FLAGS_device == "CPU" || FLAGS_device == "GPU" || FLAGS_device == "XPU")) {
+  transform(FLAGS_device.begin(),
+            FLAGS_device.end(),
+            FLAGS_device.begin(),
+            ::toupper);
+  if (!(FLAGS_device == "CPU" || FLAGS_device == "GPU" ||
+        FLAGS_device == "XPU")) {
     std::cout << "device should be 'CPU', 'GPU' or 'XPU'.";
     return -1;
   }
@@ -116,11 +132,18 @@ int main(int argc, char** argv) {
     MkDirs(FLAGS_output_dir);
   }
 
-  PaddleDetection::Pipeline pipeline(
-                    FLAGS_device, FLAGS_threshold, 
-                    FLAGS_output_dir, FLAGS_run_mode, FLAGS_gpu_id, 
-                    FLAGS_use_mkldnn, FLAGS_cpu_threads, FLAGS_trt_calib_mode,
-                    FLAGS_count, FLAGS_save_result, FLAGS_scene, FLAGS_tiny_obj, 
+  PaddleDetection::Pipeline pipeline(FLAGS_device,
+                                     FLAGS_threshold,
+                                     FLAGS_output_dir,
+                                     FLAGS_run_mode,
+                                     FLAGS_gpu_id,
+                                     FLAGS_use_mkldnn,
+                                     FLAGS_cpu_threads,
+                                     FLAGS_trt_calib_mode,
+                                     FLAGS_count,
+                                     FLAGS_save_result,
+                                     FLAGS_scene,
+                                     FLAGS_tiny_obj,
                                      FLAGS_is_mtmct);
 
   pipeline.SetInput(FLAGS_video_file);

deploy/pptracking/src/pipeline.cc

@@ -14,18 +14,17 @@
 
 #include <sstream>
 // for setprecision
+#include <chrono>
+#include <iomanip>
 #include <iostream>
 #include <string>
-#include <iomanip>
-#include <chrono>
 #include "include/pipeline.h"
 #include "include/postprocess.h"
 #include "include/predictor.h"
 
 namespace PaddleDetection {
 
-
-void Pipeline::SetInput(std::string& input_video) {
+void Pipeline::SetInput(const std::string& input_video) {
   input_.push_back(input_video);
 }
 
@@ -76,16 +75,29 @@ void Pipeline::InitPredictor() {
   }
 
   if (!track_model_dir_.empty()) {
-    jde_sct_ = std::make_shared<PaddleDetection::JDEPredictor>(device_, track_model_dir_, threshold_, run_mode_, gpu_id_, use_mkldnn_, cpu_threads_, trt_calib_mode_);
+    jde_sct_ = std::make_shared<PaddleDetection::JDEPredictor>(device_,
+                                                               track_model_dir_,
+                                                               threshold_,
+                                                               run_mode_,
+                                                               gpu_id_,
+                                                               use_mkldnn_,
+                                                               cpu_threads_,
+                                                               trt_calib_mode_);
   }
   if (!det_model_dir_.empty()) {
-    sde_sct_ = std::make_shared<PaddleDetection::SDEPredictor>(device_, det_model_dir_, reid_model_dir_, threshold_, run_mode_, gpu_id_, use_mkldnn_, cpu_threads_, trt_calib_mode_);
+    sde_sct_ = std::make_shared<PaddleDetection::SDEPredictor>(device_,
+                                                               det_model_dir_,
+                                                               reid_model_dir_,
+                                                               threshold_,
+                                                               run_mode_,
+                                                               gpu_id_,
+                                                               use_mkldnn_,
+                                                               cpu_threads_,
+                                                               trt_calib_mode_);
   }
 }
 
-
 void Pipeline::Run() {
-
   if (track_model_dir_.empty() && det_model_dir_.empty()) {
     std::cout << "Pipeline must use SelectModel before Run";
     return;
@@ -98,21 +110,21 @@ void Pipeline::Run() {
   if (!track_model_dir_.empty()) {
     // single camera
     if (input_.size() > 1) {
-      throw "Single camera tracking except single video, but received %d", input_.size();
+      throw "Single camera tracking except single video, but received %d",
+          input_.size();
     }
     PredictMOT(input_[0]);
   } else {
     // multi cameras
     if (input_.size() != 2) {
-      throw "Multi camera tracking except two videos, but received %d", input_.size();
+      throw "Multi camera tracking except two videos, but received %d",
+          input_.size();
     }
     PredictMTMCT(input_);
   }
 }
 
-
 void Pipeline::PredictMOT(const std::string& video_path) {
-
   // Open video
   cv::VideoCapture capture;
   capture.open(video_path.c_str());
@@ -134,9 +146,9 @@ void Pipeline::PredictMOT(const std::string& video_path) {
   // Create VideoWriter for output
   cv::VideoWriter video_out;
   std::string video_out_path = output_dir_ + OS_PATH_SEP + "mot_output.mp4";
-  int fcc = cv::VideoWriter::fourcc('m','p','4','v');
+  int fcc = cv::VideoWriter::fourcc('m', 'p', '4', 'v');
   video_out.open(video_out_path.c_str(),
-                 fcc, //0x00000021,
+                 fcc,  // 0x00000021,
                  video_fps,
                  cv::Size(video_width, video_height),
                  true);
@@ -172,18 +184,19 @@ void Pipeline::PredictMOT(const std::string& video_path) {
     times = total_time / frame_id;
 
     LOG(INFO) << "frame_id: " << frame_id
-              << " predict time(s): "<< total_time / 1000;
+              << " predict time(s): " << total_time / 1000;
 
     cv::Mat out_img = PaddleDetection::VisualizeTrackResult(
-        frame, result, 1000./times, frame_id);
+        frame, result, 1000. / times, frame_id);
 
     if (count_) {
       // Count total number
       // Count in & out number
-      PaddleDetection::FlowStatistic(result, frame_id, &count_list, &in_count_list, &out_count_list);
+      PaddleDetection::FlowStatistic(
+          result, frame_id, &count_list, &in_count_list, &out_count_list);
     }
     if (save_result_) {
-      PaddleDetection::SaveMOTResult(result, frame_id, records);
+      PaddleDetection::SaveMOTResult(result, frame_id, &records);
     }
     video_out.write(out_img);
   }
@@ -194,10 +207,11 @@ void Pipeline::PredictMOT(const std::string& video_path) {
   LOG(INFO) << "Total frame: " << frame_id;
   LOG(INFO) << "Visualized output saved as " << video_out_path.c_str();
   if (save_result_) {
-    FILE * fp;
+    FILE* fp;
 
-    std::string result_output_path = output_dir_ + OS_PATH_SEP + "mot_output.txt";
-    if((fp = fopen(result_output_path.c_str(), "w+")) == NULL) {
+    std::string result_output_path =
+        output_dir_ + OS_PATH_SEP + "mot_output.txt";
+    if ((fp = fopen(result_output_path.c_str(), "w+")) == NULL) {
       printf("Open %s error.\n", result_output_path.c_str());
       return;
     }
@@ -214,7 +228,13 @@ void Pipeline::PredictMTMCT(const std::vector<std::string> video_path) {
   throw "Not Implement!";
 }
 
-void Pipeline::RunMOTStream(const cv::Mat img, const int frame_id, cv::Mat& out_img, std::vector<std::string>& records, std::vector<int>& count_list, std::vector<int>& in_count_list, std::vector<int>& out_count_list) {
+void Pipeline::RunMOTStream(const cv::Mat img,
+                            const int frame_id,
+                            cv::Mat out_img,
+                            std::vector<std::string>* records,
+                            std::vector<int>* count_list,
+                            std::vector<int>* in_count_list,
+                            std::vector<int>* out_count_list) {
   PaddleDetection::MOTResult result;
   std::vector<double> det_times(3);
   double times;
@@ -228,15 +248,16 @@ void Pipeline::RunMOTStream(const cv::Mat img, const int frame_id, cv::Mat& out_
   times = total_time / frame_id;
 
   LOG(INFO) << "frame_id: " << frame_id
-            << " predict time(s): "<< total_time / 1000;
+            << " predict time(s): " << total_time / 1000;
 
   out_img = PaddleDetection::VisualizeTrackResult(
-    img, result, 1000./times, frame_id);
+      img, result, 1000. / times, frame_id);
 
   if (count_) {
     // Count total number
     // Count in & out number
-    PaddleDetection::FlowStatistic(result, frame_id, &count_list, &in_count_list, &out_count_list);
+    PaddleDetection::FlowStatistic(
+        result, frame_id, count_list, in_count_list, out_count_list);
   }
 
   PrintBenchmarkLog(det_times, frame_id);
@@ -245,23 +266,30 @@ void Pipeline::RunMOTStream(const cv::Mat img, const int frame_id, cv::Mat& out_
   }
 }
 
-void Pipeline::RunMTMCTStream(const std::vector<cv::Mat> imgs, std::vector<std::string>& records) {
+void Pipeline::RunMTMCTStream(const std::vector<cv::Mat> imgs,
+                              std::vector<std::string>* records) {
   throw "Not Implement!";
 }
 
-void Pipeline::PrintBenchmarkLog(std::vector<double> det_time, int img_num){
+void Pipeline::PrintBenchmarkLog(const std::vector<double> det_time,
+                                 const int img_num) {
   LOG(INFO) << "----------------------- Config info -----------------------";
   LOG(INFO) << "runtime_device: " << device_;
-  LOG(INFO) << "ir_optim: " << "True";
-  LOG(INFO) << "enable_memory_optim: " << "True";
+  LOG(INFO) << "ir_optim: "
+            << "True";
+  LOG(INFO) << "enable_memory_optim: "
+            << "True";
   int has_trt = run_mode_.find("trt");
   if (has_trt >= 0) {
-    LOG(INFO) << "enable_tensorrt: " << "True";
+    LOG(INFO) << "enable_tensorrt: "
+              << "True";
     std::string precision = run_mode_.substr(4, 8);
     LOG(INFO) << "precision: " << precision;
   } else {
-    LOG(INFO) << "enable_tensorrt: " << "False";
-    LOG(INFO) << "precision: " << "fp32";
+    LOG(INFO) << "enable_tensorrt: "
+              << "False";
+    LOG(INFO) << "precision: "
+              << "fp32";
   }
   LOG(INFO) << "enable_mkldnn: " << (use_mkldnn_ ? "True" : "False");
   LOG(INFO) << "cpu_math_library_num_threads: " << cpu_threads_;
@@ -269,12 +297,10 @@ void Pipeline::PrintBenchmarkLog(std::vector<double> det_time, int img_num){
   LOG(INFO) << "Total number of predicted data: " << img_num
             << " and total time spent(s): "
             << std::accumulate(det_time.begin(), det_time.end(), 0.) / 1000;
-  img_num = std::max(1, img_num);
-  LOG(INFO) << "preproce_time(ms): " << det_time[0] / img_num
-            << ", inference_time(ms): " << det_time[1] / img_num
-            << ", postprocess_time(ms): " << det_time[2] / img_num;
+  int num = std::max(1, img_num);
+  LOG(INFO) << "preproce_time(ms): " << det_time[0] / num
+            << ", inference_time(ms): " << det_time[1] / num
+            << ", postprocess_time(ms): " << det_time[2] / num;
 }
 
-
 }  // namespace PaddleDetection
-

deploy/pptracking/src/postprocess.cc

@@ -14,46 +14,47 @@
 
 #include <sstream>
 // for setprecision
-#include <iomanip>
 #include <chrono>
+#include <iomanip>
 #include "include/postprocess.h"
 
 namespace PaddleDetection {
 
 cv::Scalar GetColor(int idx) {
   idx = idx * 3;
-  cv::Scalar color = cv::Scalar((37 * idx) % 255, 
-                                (17 * idx) % 255, 
-                                (29 * idx) % 255);
+  cv::Scalar color =
+      cv::Scalar((37 * idx) % 255, (17 * idx) % 255, (29 * idx) % 255);
   return color;
 }
 
 cv::Mat VisualizeTrackResult(const cv::Mat& img,
                              const MOTResult& results,
-                        const float fps, const int frame_id) {
+                             const float fps,
+                             const int frame_id) {
   cv::Mat vis_img = img.clone();
   int im_h = img.rows;
   int im_w = img.cols;
-  float text_scale = std::max(1, int(im_w / 1600.));
+  float text_scale = std::max(1, static_cast<int>(im_w / 1600.));
   float text_thickness = 2.;
-  float line_thickness = std::max(1, int(im_w / 500.));
+  float line_thickness = std::max(1, static_cast<int>(im_w / 500.));
 
   std::ostringstream oss;
   oss << std::setiosflags(std::ios::fixed) << std::setprecision(4);
-  oss << "frame: " << frame_id<<" ";
-  oss << "fps: " << fps<<" ";
+  oss << "frame: " << frame_id << " ";
+  oss << "fps: " << fps << " ";
   oss << "num: " << results.size();
   std::string text = oss.str();
 
   cv::Point origin;
   origin.x = 0;
-  origin.y = int(15 * text_scale);
-  cv::putText(
-        vis_img,
+  origin.y = static_cast<int>(15 * text_scale);
+  cv::putText(vis_img,
               text,
               origin,
               cv::FONT_HERSHEY_PLAIN,
-        text_scale, (0, 0, 255), 2);
+              text_scale,
+              (0, 0, 255),
+              2);
 
   for (int i = 0; i < results.size(); ++i) {
     const int obj_id = results[i].ids;
@@ -63,8 +64,10 @@ cv::Mat VisualizeTrackResult(const cv::Mat& img,
 
     cv::Point pt1 = cv::Point(results[i].rects.left, results[i].rects.top);
     cv::Point pt2 = cv::Point(results[i].rects.right, results[i].rects.bottom);
-    cv::Point id_pt = cv::Point(results[i].rects.left, results[i].rects.top + 10);
-    cv::Point score_pt = cv::Point(results[i].rects.left, results[i].rects.top - 10);
+    cv::Point id_pt =
+        cv::Point(results[i].rects.left, results[i].rects.top + 10);
+    cv::Point score_pt =
+        cv::Point(results[i].rects.left, results[i].rects.top - 10);
     cv::rectangle(vis_img, pt1, pt2, color, line_thickness);
 
     std::ostringstream idoss;
@@ -92,19 +95,21 @@ cv::Mat VisualizeTrackResult(const cv::Mat& img,
                 text_scale,
                 cv::Scalar(0, 255, 255),
                 text_thickness);
-   
   }
   return vis_img;
 }
 
-void FlowStatistic(const MOTResult& results, const int frame_id,
+void FlowStatistic(const MOTResult& results,
+                   const int frame_id,
                    std::vector<int>* count_list,
                    std::vector<int>* in_count_list,
                    std::vector<int>* out_count_list) {
   throw "Not Implement";
 }
 
-void SaveMOTResult(const MOTResult& results, const int frame_id, std::vector<std::string>& records) {
+void SaveMOTResult(const MOTResult& results,
+                   const int frame_id,
+                   std::vector<std::string>* records) {
   // result format: frame_id, track_id, x1, y1, w, h
   std::string record;
   for (int i = 0; i < results.size(); ++i) {
@@ -122,11 +127,10 @@ void SaveMOTResult(const MOTResult& results, const int frame_id, std::vector<std
       continue;
     }
     std::ostringstream os;
-    os << frame_id << " " << ids << ""
-       << x1 << " " << y1 << " "
-       << w << " " << h <<"\n";
+    os << frame_id << " " << ids << "" << x1 << " " << y1 << " " << w << " "
+       << h << "\n";
     record = os.str();
-    records.push_back(record);
+    records->push_back(record);
   }
 }
 

deploy/pptracking/src/preprocess_op.cc

@@ -12,24 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <vector>
 #include <string>
 #include <thread>
+#include <vector>
 
 #include "include/preprocess_op.h"
 
 namespace PaddleDetection {
 
 void InitInfo::Run(cv::Mat* im, ImageBlob* data) {
-  data->im_shape_ = {
-      static_cast<float>(im->rows),
-      static_cast<float>(im->cols)
-  };
+  data->im_shape_ = {static_cast<float>(im->rows),
+                     static_cast<float>(im->cols)};
   data->scale_factor_ = {1., 1.};
-  data->in_net_shape_ = {
-      static_cast<float>(im->rows),
-      static_cast<float>(im->cols)
-  };
+  data->in_net_shape_ = {static_cast<float>(im->rows),
+                         static_cast<float>(im->cols)};
 }
 
 void NormalizeImage::Run(cv::Mat* im, ImageBlob* data) {
@@ -41,11 +37,11 @@ void NormalizeImage::Run(cv::Mat* im, ImageBlob* data) {
   for (int h = 0; h < im->rows; h++) {
     for (int w = 0; w < im->cols; w++) {
       im->at<cv::Vec3f>(h, w)[0] =
-          (im->at<cv::Vec3f>(h, w)[0] - mean_[0] ) / scale_[0];
+          (im->at<cv::Vec3f>(h, w)[0] - mean_[0]) / scale_[0];
       im->at<cv::Vec3f>(h, w)[1] =
-          (im->at<cv::Vec3f>(h, w)[1] - mean_[1] ) / scale_[1];
+          (im->at<cv::Vec3f>(h, w)[1] - mean_[1]) / scale_[1];
       im->at<cv::Vec3f>(h, w)[2] =
-          (im->at<cv::Vec3f>(h, w)[2] - mean_[2] ) / scale_[2];
+          (im->at<cv::Vec3f>(h, w)[2] - mean_[2]) / scale_[2];
     }
   }
 }
@@ -64,27 +60,20 @@ void Permute::Run(cv::Mat* im, ImageBlob* data) {
 
 void Resize::Run(cv::Mat* im, ImageBlob* data) {
   auto resize_scale = GenerateScale(*im);
-  data->im_shape_ = {
-      static_cast<float>(im->cols * resize_scale.first),
-      static_cast<float>(im->rows * resize_scale.second)
-  };
-  data->in_net_shape_ = {
-      static_cast<float>(im->cols * resize_scale.first),
-      static_cast<float>(im->rows * resize_scale.second)
-  };
+  data->im_shape_ = {static_cast<float>(im->cols * resize_scale.first),
+                     static_cast<float>(im->rows * resize_scale.second)};
+  data->in_net_shape_ = {static_cast<float>(im->cols * resize_scale.first),
+                         static_cast<float>(im->rows * resize_scale.second)};
   cv::resize(
       *im, *im, cv::Size(), resize_scale.first, resize_scale.second, interp_);
   data->im_shape_ = {
-    static_cast<float>(im->rows),
-    static_cast<float>(im->cols),
+      static_cast<float>(im->rows), static_cast<float>(im->cols),
   };
   data->scale_factor_ = {
-    resize_scale.second,
-    resize_scale.first,
+      resize_scale.second, resize_scale.first,
   };
 }
 
-
 std::pair<float, float> Resize::GenerateScale(const cv::Mat& im) {
   std::pair<float, float> resize_scale;
   int origin_w = im.cols;
@@ -93,8 +82,10 @@ std::pair<float, float> Resize::GenerateScale(const cv::Mat& im) {
   if (keep_ratio_) {
     int im_size_max = std::max(origin_w, origin_h);
     int im_size_min = std::min(origin_w, origin_h);
-    int target_size_max = *std::max_element(target_size_.begin(), target_size_.end());
-    int target_size_min = *std::min_element(target_size_.begin(), target_size_.end());
+    int target_size_max =
+        *std::max_element(target_size_.begin(), target_size_.end());
+    int target_size_min =
+        *std::min_element(target_size_.begin(), target_size_.end());
     float scale_min =
         static_cast<float>(target_size_min) / static_cast<float>(im_size_min);
     float scale_max =
@@ -114,10 +105,8 @@ void LetterBoxResize::Run(cv::Mat* im, ImageBlob* data) {
   float resize_scale = GenerateScale(*im);
   int new_shape_w = std::round(im->cols * resize_scale);
   int new_shape_h = std::round(im->rows * resize_scale);
-  data->im_shape_ = {
-      static_cast<float>(new_shape_h),
-      static_cast<float>(new_shape_w)
-  };
+  data->im_shape_ = {static_cast<float>(new_shape_h),
+                     static_cast<float>(new_shape_w)};
   float padw = (target_size_[1] - new_shape_w) / 2.;
   float padh = (target_size_[0] - new_shape_h) / 2.;
 
@@ -130,11 +119,9 @@ void LetterBoxResize::Run(cv::Mat* im, ImageBlob* data) {
       *im, *im, cv::Size(new_shape_w, new_shape_h), 0, 0, cv::INTER_AREA);
 
   data->in_net_shape_ = {
-    static_cast<float>(im->rows),
-    static_cast<float>(im->cols),
+      static_cast<float>(im->rows), static_cast<float>(im->cols),
   };
-  cv::copyMakeBorder(
-    *im,
+  cv::copyMakeBorder(*im,
                      *im,
                      top,
                      bottom,
@@ -144,16 +131,12 @@ void LetterBoxResize::Run(cv::Mat* im, ImageBlob* data) {
                      cv::Scalar(127.5));
 
   data->in_net_shape_ = {
-    static_cast<float>(im->rows),
-    static_cast<float>(im->cols),
+      static_cast<float>(im->rows), static_cast<float>(im->cols),
   };
 
   data->scale_factor_ = {
-    resize_scale,
-    resize_scale,
+      resize_scale, resize_scale,
   };
- 
-
 }
 
 float LetterBoxResize::GenerateScale(const cv::Mat& im) {
@@ -179,24 +162,19 @@ void PadStride::Run(cv::Mat* im, ImageBlob* data) {
   int nh = (rh / stride_) * stride_ + (rh % stride_ != 0) * stride_;
   int nw = (rw / stride_) * stride_ + (rw % stride_ != 0) * stride_;
   cv::copyMakeBorder(
-    *im,
-    *im,
-    0,
-    nh - rh,
-    0,
-    nw - rw,
-    cv::BORDER_CONSTANT,
-    cv::Scalar(0));
+      *im, *im, 0, nh - rh, 0, nw - rw, cv::BORDER_CONSTANT, cv::Scalar(0));
   data->in_net_shape_ = {
-    static_cast<float>(im->rows),
-    static_cast<float>(im->cols),
+      static_cast<float>(im->rows), static_cast<float>(im->cols),
   };
 }
 
 // Preprocessor op running order
-const std::vector<std::string> Preprocessor::RUN_ORDER = {
-  "InitInfo", "Resize", "LetterBoxResize", "NormalizeImage", "PadStride", "Permute"
-};
+const std::vector<std::string> Preprocessor::RUN_ORDER = {"InitInfo",
+                                                          "Resize",
+                                                          "LetterBoxResize",
+                                                          "NormalizeImage",
+                                                          "PadStride",
+                                                          "Permute"};
 
 void Preprocessor::Run(cv::Mat* im, ImageBlob* data) {
   for (const auto& name : RUN_ORDER) {

deploy/pptracking/src/sde_predictor.cc

@@ -13,12 +13,11 @@
 // limitations under the License.
 #include <sstream>
 // for setprecision
-#include <iomanip>
 #include <chrono>
+#include <iomanip>
 #include "include/sde_predictor.h"
 
-
-using namespace paddle_infer;
+using namespace paddle_infer;  // NOLINT
 
 namespace PaddleDetection {
 
@@ -29,13 +28,10 @@ void SDEPredictor::LoadModel(const std::string& det_model_dir,
   throw "Not Implement";
 }
 
+void SDEPredictor::Preprocess(const cv::Mat& ori_im) { throw "Not Implement"; }
 
-void SDEPredictor::Preprocess(const cv::Mat& ori_im) {
-  throw "Not Implement";
-}
-
-void SDEPredictor::Postprocess(
-    const cv::Mat dets, const cv::Mat emb,
+void SDEPredictor::Postprocess(const cv::Mat dets,
+                               const cv::Mat emb,
                                MOTResult* result) {
   throw "Not Implement";
 }

deploy/pptracking/src/tracker.cc

@@ -17,20 +17,23 @@
 // Ths copyright of CnybTseng/JDE is as follows:
 // MIT License
 
-#include <map>
-#include <stdio.h>
 #include <limits.h>
+#include <stdio.h>
 #include <algorithm>
+#include <map>
 
 #include "include/lapjv.h"
 #include "include/tracker.h"
 
-#define mat2vec4f(m) cv::Vec4f(*m.ptr<float>(0,0), *m.ptr<float>(0,1), *m.ptr<float>(0,2), *m.ptr<float>(0,3))
+#define mat2vec4f(m)             \
+  cv::Vec4f(*m.ptr<float>(0, 0), \
+            *m.ptr<float>(0, 1), \
+            *m.ptr<float>(0, 2), \
+            *m.ptr<float>(0, 3))
 
 namespace PaddleDetection {
 
-static std::map<int, float> chi2inv95 = {
-    {1,  3.841459f},
+static std::map<int, float> chi2inv95 = {{1, 3.841459f},
                                          {2, 5.991465f},
                                          {3, 7.814728f},
                                          {4, 9.487729f},
@@ -38,26 +41,21 @@ static std::map<int, float> chi2inv95 = {
                                          {6, 12.591587f},
                                          {7, 14.067140f},
                                          {8, 15.507313f},
-    {9, 16.918978f}
-};
+                                         {9, 16.918978f}};
 
 JDETracker *JDETracker::me = new JDETracker;
 
-JDETracker *JDETracker::instance(void)
-{
-    return me;
-}
+JDETracker *JDETracker::instance(void) { return me; }
 
-JDETracker::JDETracker(void) : timestamp(0), max_lost_time(30), lambda(0.98f), det_thresh(0.3f)
-{    
-}
+JDETracker::JDETracker(void)
+    : timestamp(0), max_lost_time(30), lambda(0.98f), det_thresh(0.3f) {}
 
-bool JDETracker::update(const cv::Mat &dets, const cv::Mat &emb, std::vector<Track> &tracks)
-{
+bool JDETracker::update(const cv::Mat &dets,
+                        const cv::Mat &emb,
+                        std::vector<Track> *tracks) {
   ++timestamp;
   TrajectoryPool candidates(dets.rows);
-    for (int i = 0; i < dets.rows; ++i)
-    {
+  for (int i = 0; i < dets.rows; ++i) {
     float score = *dets.ptr<float>(i, 4);
     const cv::Mat &ltrb_ = dets(cv::Rect(0, i, 4, 1));
     cv::Vec4f ltrb = mat2vec4f(ltrb_);
@@ -65,19 +63,17 @@ bool JDETracker::update(const cv::Mat &dets, const cv::Mat &emb, std::vector<Tra
     candidates[i] = Trajectory(ltrb, score, embedding);
   }
 
-    
   TrajectoryPtrPool tracked_trajectories;
   TrajectoryPtrPool unconfirmed_trajectories;
-    for (size_t i = 0; i < this->tracked_trajectories.size(); ++i)
-    {
+  for (size_t i = 0; i < this->tracked_trajectories.size(); ++i) {
     if (this->tracked_trajectories[i].is_activated)
       tracked_trajectories.push_back(&this->tracked_trajectories[i]);
     else
       unconfirmed_trajectories.push_back(&this->tracked_trajectories[i]);
   }
 
-    
-    TrajectoryPtrPool trajectory_pool = tracked_trajectories + this->lost_trajectories;
+  TrajectoryPtrPool trajectory_pool =
+      tracked_trajectories + &(this->lost_trajectories);
 
   for (size_t i = 0; i < trajectory_pool.size(); ++i)
     trajectory_pool[i]->predict();
@@ -87,25 +83,20 @@ bool JDETracker::update(const cv::Mat &dets, const cv::Mat &emb, std::vector<Tra
   std::vector<int> mismatch_col;
 
   cv::Mat cost = motion_distance(trajectory_pool, candidates);
-    linear_assignment(cost, 0.7f, matches, mismatch_row, mismatch_col);
+  linear_assignment(cost, 0.7f, &matches, &mismatch_row, &mismatch_col);
 
   MatchIterator miter;
   TrajectoryPtrPool activated_trajectories;
   TrajectoryPtrPool retrieved_trajectories;
 
-    
-    for (miter = matches.begin(); miter != matches.end(); miter++)
-    {
+  for (miter = matches.begin(); miter != matches.end(); miter++) {
     Trajectory *pt = trajectory_pool[miter->first];
     Trajectory &ct = candidates[miter->second];
-        if (pt->state == Tracked)
-        {
-            pt->update(ct, timestamp);
+    if (pt->state == Tracked) {
+      pt->update(&ct, timestamp);
       activated_trajectories.push_back(pt);
-        }
-        else
-        {
-            pt->reactivate(ct, timestamp);
+    } else {
+      pt->reactivate(&ct, timestamp);
       retrieved_trajectories.push_back(pt);
     }
   }
@@ -115,38 +106,31 @@ bool JDETracker::update(const cv::Mat &dets, const cv::Mat &emb, std::vector<Tra
     next_candidates[i] = &candidates[mismatch_col[i]];
 
   TrajectoryPtrPool next_trajectory_pool;
-    for (size_t i = 0; i < mismatch_row.size(); ++i)
-    {
+  for (size_t i = 0; i < mismatch_row.size(); ++i) {
     int j = mismatch_row[i];
     if (trajectory_pool[j]->state == Tracked)
       next_trajectory_pool.push_back(trajectory_pool[j]);
   }
 
   cost = iou_distance(next_trajectory_pool, next_candidates);
-    linear_assignment(cost, 0.5f, matches, mismatch_row, mismatch_col);
+  linear_assignment(cost, 0.5f, &matches, &mismatch_row, &mismatch_col);
 
-    for (miter = matches.begin(); miter != matches.end(); miter++)
-    {
+  for (miter = matches.begin(); miter != matches.end(); miter++) {
     Trajectory *pt = next_trajectory_pool[miter->first];
     Trajectory *ct = next_candidates[miter->second];
-        if (pt->state == Tracked)
-        {
-            pt->update(*ct, timestamp);
+    if (pt->state == Tracked) {
+      pt->update(ct, timestamp);
       activated_trajectories.push_back(pt);
-        }
-        else
-        {
-            pt->reactivate(*ct, timestamp);
+    } else {
+      pt->reactivate(ct, timestamp);
       retrieved_trajectories.push_back(pt);
     }
   }
 
   TrajectoryPtrPool lost_trajectories;
-    for (size_t i = 0; i < mismatch_row.size(); ++i)
-    {
+  for (size_t i = 0; i < mismatch_row.size(); ++i) {
     Trajectory *pt = next_trajectory_pool[mismatch_row[i]];
-        if (pt->state != Lost)
-        {
+    if (pt->state != Lost) {
       pt->mark_lost();
       lost_trajectories.push_back(pt);
     }
@@ -156,42 +140,38 @@ bool JDETracker::update(const cv::Mat &dets, const cv::Mat &emb, std::vector<Tra
   for (size_t i = 0; i < mismatch_col.size(); ++i)
     nnext_candidates[i] = next_candidates[mismatch_col[i]];
   cost = iou_distance(unconfirmed_trajectories, nnext_candidates);
-    linear_assignment(cost, 0.7f, matches, mismatch_row, mismatch_col);
+  linear_assignment(cost, 0.7f, &matches, &mismatch_row, &mismatch_col);
 
-    for (miter = matches.begin(); miter != matches.end(); miter++)
-    {
-        unconfirmed_trajectories[miter->first]->update(*nnext_candidates[miter->second], timestamp);
+  for (miter = matches.begin(); miter != matches.end(); miter++) {
+    unconfirmed_trajectories[miter->first]->update(
+        nnext_candidates[miter->second], timestamp);
     activated_trajectories.push_back(unconfirmed_trajectories[miter->first]);
   }
 
   TrajectoryPtrPool removed_trajectories;
 
-    for (size_t i = 0; i < mismatch_row.size(); ++i)
-    {
+  for (size_t i = 0; i < mismatch_row.size(); ++i) {
     unconfirmed_trajectories[mismatch_row[i]]->mark_removed();
     removed_trajectories.push_back(unconfirmed_trajectories[mismatch_row[i]]);
   }
 
-    for (size_t i = 0; i < mismatch_col.size(); ++i)
-    {
+  for (size_t i = 0; i < mismatch_col.size(); ++i) {
     if (nnext_candidates[mismatch_col[i]]->score < det_thresh) continue;
     nnext_candidates[mismatch_col[i]]->activate(timestamp);
     activated_trajectories.push_back(nnext_candidates[mismatch_col[i]]);
   }
 
-    for (size_t i = 0; i < this->lost_trajectories.size(); ++i)
-    {
+  for (size_t i = 0; i < this->lost_trajectories.size(); ++i) {
     Trajectory &lt = this->lost_trajectories[i];
-        if (timestamp - lt.timestamp > max_lost_time)
-        {
+    if (timestamp - lt.timestamp > max_lost_time) {
       lt.mark_removed();
       removed_trajectories.push_back(&lt);
     }
   }
 
   TrajectoryPoolIterator piter;
-    for (piter = this->tracked_trajectories.begin(); piter != this->tracked_trajectories.end(); )
-    {
+  for (piter = this->tracked_trajectories.begin();
+       piter != this->tracked_trajectories.end();) {
     if (piter->state != Tracked)
       piter = this->tracked_trajectories.erase(piter);
     else
@@ -205,26 +185,23 @@ bool JDETracker::update(const cv::Mat &dets, const cv::Mat &emb, std::vector<Tra
   this->lost_trajectories += lost_trajectories;
   this->lost_trajectories -= this->removed_trajectories;
   this->removed_trajectories += removed_trajectories;
-    remove_duplicate_trajectory(this->tracked_trajectories, this->lost_trajectories);
+  remove_duplicate_trajectory(&this->tracked_trajectories,
+                              &this->lost_trajectories);
 
-    tracks.clear();
-    for (size_t i = 0; i < this->tracked_trajectories.size(); ++i)
-    {
-        if (this->tracked_trajectories[i].is_activated)
-        {
-            Track track = {
-                .id = this->tracked_trajectories[i].id,
+  tracks->clear();
+  for (size_t i = 0; i < this->tracked_trajectories.size(); ++i) {
+    if (this->tracked_trajectories[i].is_activated) {
+      Track track = {.id = this->tracked_trajectories[i].id,
                      .score = this->tracked_trajectories[i].score,
                      .ltrb = this->tracked_trajectories[i].ltrb};
-            tracks.push_back(track);
+      tracks->push_back(track);
     }
   }
   return 0;
 }
 
-
-cv::Mat JDETracker::motion_distance(const TrajectoryPtrPool &a, const TrajectoryPool &b)
-{
+cv::Mat JDETracker::motion_distance(const TrajectoryPtrPool &a,
+                                    const TrajectoryPool &b) {
   if (0 == a.size() || 0 == b.size())
     return cv::Mat(a.size(), b.size(), CV_32F);
 
@@ -233,10 +210,8 @@ cv::Mat JDETracker::motion_distance(const TrajectoryPtrPool &a, const Trajectory
   cv::Mat fdists = lambda * edists + (1 - lambda) * mdists;
 
   const float gate_thresh = chi2inv95[4];
-    for (int i = 0; i < fdists.rows; ++i)
-    {
-        for (int j = 0; j < fdists.cols; ++j)
-        {
+  for (int i = 0; i < fdists.rows; ++i) {
+    for (int j = 0; j < fdists.cols; ++j) {
       if (*mdists.ptr<float>(i, j) > gate_thresh)
         *fdists.ptr<float>(i, j) = FLT_MAX;
     }
@@ -245,18 +220,17 @@ cv::Mat JDETracker::motion_distance(const TrajectoryPtrPool &a, const Trajectory
   return fdists;
 }
 
-void JDETracker::linear_assignment(const cv::Mat &cost, float cost_limit, Match &matches,
-    std::vector<int> &mismatch_row, std::vector<int> &mismatch_col)
-{
-    matches.clear();
-    mismatch_row.clear();    
-    mismatch_col.clear();
-    if (cost.empty())
-    {
-        for (int i = 0; i < cost.rows; ++i)
-            mismatch_row.push_back(i);
-        for (int i = 0; i < cost.cols; ++i)
-            mismatch_col.push_back(i);
+void JDETracker::linear_assignment(const cv::Mat &cost,
+                                   float cost_limit,
+                                   Match *matches,
+                                   std::vector<int> *mismatch_row,
+                                   std::vector<int> *mismatch_col) {
+  matches->clear();
+  mismatch_row->clear();
+  mismatch_col->clear();
+  if (cost.empty()) {
+    for (int i = 0; i < cost.rows; ++i) mismatch_row->push_back(i);
+    for (int i = 0; i < cost.cols; ++i) mismatch_col->push_back(i);
     return;
   }
 
@@ -264,44 +238,43 @@ void JDETracker::linear_assignment(const cv::Mat &cost, float cost_limit, Match
   cv::Mat x(cost.rows, 1, CV_32S);
   cv::Mat y(cost.cols, 1, CV_32S);
 
-    lapjv_internal(cost, true, cost_limit,
-        (int *)x.data, (int *)y.data);
+  lapjv_internal(cost,
+                 true,
+                 cost_limit,
+                 reinterpret_cast<int *>(x.data),
+                 reinterpret_cast<int *>(y.data));
 
-    for (int i = 0; i < x.rows; ++i)
-    {
+  for (int i = 0; i < x.rows; ++i) {
     int j = *x.ptr<int>(i);
     if (j >= 0)
-            matches.insert({i, j});
+      matches->insert({i, j});
     else
-            mismatch_row.push_back(i);
+      mismatch_row->push_back(i);
   }
 
-    for (int i = 0; i < y.rows; ++i)
-    {
+  for (int i = 0; i < y.rows; ++i) {
     int j = *y.ptr<int>(i);
-        if (j < 0)
-            mismatch_col.push_back(i);
+    if (j < 0) mismatch_col->push_back(i);
   }
 
   return;
 }
 
-void JDETracker::remove_duplicate_trajectory(TrajectoryPool &a, TrajectoryPool &b, float iou_thresh)
-{
-    if (0 == a.size() || 0 == b.size())
-        return;
+void JDETracker::remove_duplicate_trajectory(TrajectoryPool *a,
+                                             TrajectoryPool *b,
+                                             float iou_thresh) {
+  if (a->size() == 0 || b->size() == 0) return;
 
-    cv::Mat dist = iou_distance(a, b);
+  cv::Mat dist = iou_distance(*a, *b);
   cv::Mat mask = dist < iou_thresh;
   std::vector<cv::Point> idx;
   cv::findNonZero(mask, idx);
 
   std::vector<int> da;
   std::vector<int> db;
-    for (size_t i = 0; i < idx.size(); ++i)
-    {
-        int ta = a[idx[i].y].timestamp - a[idx[i].y].starttime;
-        int tb = b[idx[i].x].timestamp - b[idx[i].x].starttime;
+  for (size_t i = 0; i < idx.size(); ++i) {
+    int ta = (*a)[idx[i].y].timestamp - (*a)[idx[i].y].starttime;
+    int tb = (*b)[idx[i].x].timestamp - (*b)[idx[i].x].starttime;
     if (ta > tb)
       db.push_back(idx[i].x);
     else
@@ -310,21 +283,19 @@ void JDETracker::remove_duplicate_trajectory(TrajectoryPool &a, TrajectoryPool &
 
   int id = 0;
   TrajectoryPoolIterator piter;
-    for (piter = a.begin(); piter != a.end(); )
-    {
+  for (piter = a->begin(); piter != a->end();) {
     std::vector<int>::iterator iter = find(da.begin(), da.end(), id++);
     if (iter != da.end())
-            piter = a.erase(piter);
+      piter = a->erase(piter);
     else
       ++piter;
   }
 
   id = 0;
-    for (piter = b.begin(); piter != b.end(); )
-    {
+  for (piter = b->begin(); piter != b->end();) {
     std::vector<int>::iterator iter = find(db.begin(), db.end(), id++);
     if (iter != db.end())
-            piter = b.erase(piter);
+      piter = b->erase(piter);
     else
       ++piter;
   }