├── include
    ├── hungarianoper.h
    ├── deepsortenginegenerator.h
    ├── kalmanfilter.h
    ├── model.hpp
    ├── deepsort.h
    ├── nn_matching.h
    ├── linear_assignment.h
    ├── featuretensor.h
    ├── tracker.h
    ├── datatype.h
    ├── track.h
    ├── matrix.h
    ├── munkres.h
    └── logging.h
├── README.md
├── onnx2engine.cpp
├── src
    ├── munkres.cpp
    ├── hungarianoper.cpp
    ├── deepsortenginegenerator.cpp
    ├── track.cpp
    ├── deepsort.cpp
    ├── kalmanfilter.cpp
    ├── nn_matching.cpp
    ├── featuretensor.cpp
    ├── linear_assignment.cpp
    └── tracker.cpp
├── CMakeLists.txt
├── CMakeLists_deepsort-tensorrt_win10.txt
├── exportOnnx.py
├── demo.cpp
└── LICENSE


/include/hungarianoper.h:
--------------------------------------------------------------------------------
 1 | #ifndef HUNGARIANOPER_H
 2 | #define HUNGARIANOPER_H
 3 | 
 4 | #include "munkres.h"
 5 | #include "datatype.h"
 6 | 
 7 | 
 8 | class HungarianOper {
 9 | public:
10 |     static Eigen::Matrix<float, -1, 2, Eigen::RowMajor> Solve(const DYNAMICM &cost_matrix);
11 | };
12 | 
13 | #endif // HUNGARIANOPER_H
14 | 


--------------------------------------------------------------------------------
/include/deepsortenginegenerator.h:
--------------------------------------------------------------------------------
 1 | #ifndef DEEPSORT_ENGINE_GENERATOR_H
 2 | #define DEEPSORT_ENGINE_GENERATOR_H
 3 | 
 4 | #include <iostream>
 5 | #include <NvInfer.h>
 6 | #include <NvOnnxParser.h>
 7 | 
 8 | using namespace nvinfer1;
 9 | 
10 | const int IMG_HEIGHT = 128;
11 | const int IMG_WIDTH = 64;
12 | const int MAX_BATCH_SIZE = 128;
13 | const std::string INPUT_NAME("input");
14 | 
15 | class DeepSortEngineGenerator {
16 | public:
17 |     DeepSortEngineGenerator(ILogger* gLogger);
18 |     ~DeepSortEngineGenerator();
19 | 
20 | public:
21 |     void setFP16(bool state);
22 |     void createEngine(std::string onnxPath, std::string enginePath);
23 | 
24 | private: 
25 |     std::string modelPath, engingPath;
26 |     ILogger* gLogger;  
27 |     bool useFP16; 
28 | };
29 | 
30 | #endif


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DeepSort_TensorRT
 2 | Use tensorrt to accelerate deepsort tracking.
 3 | 使用tensorrt来加速deepsort的特征提取。
 4 | ## Install
 5 | [REQUIRE] TensorRT 7</p>
 6 | [REQUIRE] OpenCV</p>
 7 | 下载本库和deepsort的pytorch库
 8 | ```
 9 | git clone git@github.com:ZQPei/deep_sort_pytorch.git
10 | git clone https://github.com/RichardoMrMu/deepsort-tensorrt.git
11 | ```
12 | 配置好pytorch工程后，将exportOnnx.py复制到pytorch工程的项目目录下运行，将会生成deepsort.onnx。</p>
13 | 把deepsort.onnx移到本工程的resources目录下。然后回到工程的根目录</p>
14 | ```
15 | mkdir build
16 | cd build
17 | cmake ..
18 | make
19 | ./onnx2engine ../resources/deepsort.onnx ../resources/deepsort.engine
20 | ```
21 | 然后就可以运行demo测试了</p>
22 | ```
23 | ./demo ../resources/deepsort.engine ../resources/track.txt
24 | ```
25 | 然后就可以把自己TensorRT的目标检测工程进行对接。
26 | ```
27 | git clone https://github.com/wang-xinyu/tensorrtx.git
28 | ```
29 | 注：视频文件太大，所以只把检测结果保存成txt进行测试。
30 | 


--------------------------------------------------------------------------------
/onnx2engine.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <NvInfer.h>
 3 | #include "deepsortenginegenerator.h"
 4 | #include "cuda_runtime_api.h"
 5 | #include "logging.h"
 6 | 
 7 | using namespace nvinfer1;
 8 | 
 9 | static Logger gLogger;
10 | 
11 | int main(int argc, char** argv) {
12 |     cudaSetDevice(0);
13 |     if (argc < 3) {
14 |         std::cout << "./onnx2engine [input .onnx path] [output .engine path]" << std::endl;
15 |         return -1;
16 |     }
17 |     std::string onnxPath = argv[1];
18 |     std::string enginePath = argv[2];
19 |     DeepSortEngineGenerator* engG = new DeepSortEngineGenerator(&gLogger);
20 |     engG->setFP16(true);
21 |     engG->createEngine(onnxPath, enginePath);
22 |     std::cout << "==============" << std::endl;
23 |     std::cout << "|  SUCCESS!  |" << std::endl;
24 |     std::cout << "==============" << std::endl;
25 |     return 0;
26 | }
27 | 
28 |     
29 | 


--------------------------------------------------------------------------------
/src/munkres.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *   Copyright (c) 2007 John Weaver
 3 |  *   Copyright (c) 2015 Miroslav Krajicek
 4 |  *
 5 |  *   This program is free software; you can redistribute it and/or modify
 6 |  *   it under the terms of the GNU General Public License as published by
 7 |  *   the Free Software Foundation; either version 2 of the License, or
 8 |  *   (at your option) any later version.
 9 |  *
10 |  *   This program is distributed in the hope that it will be useful,
11 |  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  *   GNU General Public License for more details.
14 |  *
15 |  *   You should have received a copy of the GNU General Public License
16 |  *   along with this program; if not, write to the Free Software
17 |  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
18 |  */
19 | 
20 | #include "munkres.h"
21 | 
22 | template class Munkres<double>;
23 | template class Munkres<float>;
24 | template class Munkres<int>;
25 | 
26 | 


--------------------------------------------------------------------------------
/include/kalmanfilter.h:
--------------------------------------------------------------------------------
 1 | #ifndef KALMANFILTER_H
 2 | #define KALMANFILTER_H
 3 | 
 4 | #include "datatype.h"
 5 | 
 6 | class KalmanFilter {
 7 | public:
 8 |     static const double chi2inv95[10];
 9 |     KalmanFilter();
10 |     KAL_DATA initiate(const DETECTBOX& measurement);
11 |     void predict(KAL_MEAN& mean, KAL_COVA& covariance);
12 |     KAL_HDATA project(const KAL_MEAN& mean, const KAL_COVA& covariance);
13 |     KAL_DATA update(const KAL_MEAN& mean, 
14 |                     const KAL_COVA& covariance, 
15 |                     const DETECTBOX& measurement);
16 | 
17 |     Eigen::Matrix<float, 1, -1> gating_distance(
18 |             const KAL_MEAN& mean,
19 |             const KAL_COVA& covariance,
20 |             const std::vector<DETECTBOX>& measurements,
21 |             bool only_position = false);
22 | 
23 | private:
24 |     Eigen::Matrix<float, 8, 8, Eigen::RowMajor> _motion_mat;
25 |     Eigen::Matrix<float, 4, 8, Eigen::RowMajor> _update_mat;
26 |     float _std_weight_position;
27 |     float _std_weight_velocity;
28 | };
29 | 
30 | #endif // KALMANFILTER_H
31 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.6)
 2 | project(deepsort)
 3 | 
 4 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 5 | set(CMAKE_BUILD_TYPE Release)
 6 | 
 7 | find_package(CUDA REQUIRED)
 8 | find_package(OpenCV REQUIRED)
 9 | 
10 | 
11 | include_directories(
12 |     ${CUDA_INCLUDE_DIRS}
13 |     ${OpenCV_INCLUDE_DIRS}
14 |     ${PROJECT_SOURCE_DIR}/include
15 | )
16 | link_directories(
17 |     /usr/local/cuda/lib64
18 | )
19 | aux_source_directory(${PROJECT_SOURCE_DIR}/src SRC_DIR)
20 | 
21 | # ===== deepsort =====
22 | add_library(deepsort SHARED ${SRC_DIR})
23 | target_link_libraries(deepsort 
24 |     ${CUDA_LIBS} ${OpenCV_LIBS} 
25 |     cudart nvinfer nvonnxparser
26 | )
27 | 
28 | # ===== onnx2engine =====
29 | add_executable(onnx2engine ${PROJECT_SOURCE_DIR}/onnx2engine.cpp)
30 | target_link_libraries(onnx2engine
31 |     ${CUDA_LIBS}
32 |     cudart nvinfer nvonnxparser deepsort
33 | )
34 | 
35 | # ===== demo =====
36 | add_executable(demo ${PROJECT_SOURCE_DIR}/demo.cpp)
37 | target_link_libraries(demo 
38 |     ${CUDA_LIBS} ${OpenCV_LIBS} 
39 |     cudart nvinfer nvonnxparser deepsort
40 | )
41 | 
42 | 
43 | 


--------------------------------------------------------------------------------
/src/hungarianoper.cpp:
--------------------------------------------------------------------------------
 1 | #include "hungarianoper.h"
 2 | 
 3 | Eigen::Matrix<float, -1, 2, Eigen::RowMajor> HungarianOper::Solve(const DYNAMICM &cost_matrix) {
 4 |     int rows = cost_matrix.rows();
 5 |     int cols = cost_matrix.cols();
 6 |     Matrix<double> matrix(rows, cols);
 7 |     for (int row = 0; row < rows; row++) {
 8 |         for (int col = 0; col < cols; col++) {
 9 |             matrix(row, col) = cost_matrix(row, col);
10 |         }
11 |     }
12 |     //Munkres get matrix;
13 |     Munkres<double> m;
14 |     m.solve(matrix);
15 | 
16 |     //
17 |     std::vector<std::pair<int, int>> pairs;
18 |     for (int row = 0; row < rows; row++) {
19 |         for (int col = 0; col < cols; col++) {
20 |             int tmp = (int)matrix(row, col);
21 |             if (tmp == 0) pairs.push_back(std::make_pair(row, col));
22 |         }
23 |     }
24 |     //
25 |     int count = pairs.size();
26 |     Eigen::Matrix<float, -1, 2, Eigen::RowMajor> re(count, 2);
27 |     for (int i = 0; i < count; i++) {
28 |         re(i, 0) = pairs[i].first;
29 |         re(i, 1) = pairs[i].second;
30 |     }
31 |     return re;
32 | }//end Solve;
33 | 


--------------------------------------------------------------------------------
/include/model.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef MODEL_HPP
 2 | #define MODEL_HPP
 3 | 
 4 | #include <algorithm>
 5 | #include "datatype.h"
 6 | 
 7 | 
 8 | // * Each rect's data structure.
 9 | // * tlwh: topleft point & (w,h)
10 | // * confidence: detection confidence.
11 | // * feature: the rect's 256d feature.
12 | // */
13 | 
14 | const float kRatio=0.5;
15 | enum DETECTBOX_IDX {IDX_X = 0, IDX_Y, IDX_W, IDX_H };
16 | 
17 | class DETECTION_ROW {
18 | public:
19 |     DETECTBOX tlwh;
20 |     float confidence;
21 |     FEATURE feature;
22 |     DETECTBOX to_xyah() const {
23 |         //(centerx, centery, ration, h)
24 |         DETECTBOX ret = tlwh;
25 |         ret(0, IDX_X) += (ret(0, IDX_W)*kRatio);
26 |         ret(0, IDX_Y) += (ret(0, IDX_H)*kRatio);
27 |         ret(0, IDX_W) /= ret(0, IDX_H);
28 |         return ret;
29 |     }
30 |     DETECTBOX to_tlbr() const {
31 |         //(x,y,xx,yy)
32 |         DETECTBOX ret = tlwh;
33 |         ret(0, IDX_X) += ret(0, IDX_W);
34 |         ret(0, IDX_Y) += ret(0, IDX_H);
35 |         return ret;
36 |     }
37 | };
38 | 
39 | typedef std::vector<DETECTION_ROW> DETECTIONS;
40 | typedef std::pair<std::vector<CLSCONF>, DETECTIONS> DETECTIONSV2;
41 | 
42 | #endif // MODEL_HPP
43 | 


--------------------------------------------------------------------------------
/include/deepsort.h:
--------------------------------------------------------------------------------
 1 | #ifndef DEEPSORT_H
 2 | #define DEEPSORT_H
 3 | 
 4 | #include <iostream>
 5 | #include <opencv2/opencv.hpp>
 6 | #include "featuretensor.h"
 7 | #include "tracker.h"
 8 | #include "datatype.h"
 9 | #include <vector>
10 | 
11 | using std::vector;
12 | using nvinfer1::ILogger;
13 | 
14 | class DeepSort {
15 | public:    
16 |     DeepSort(std::string modelPath, int batchSize, int featureDim, int gpuID, ILogger* gLogger);
17 |     ~DeepSort();
18 | 
19 | public:
20 |     void sort(cv::Mat& frame, vector<DetectBox>& dets);
21 | 
22 | private:
23 |     void sort(cv::Mat& frame, DETECTIONS& detections);
24 |     void sort(cv::Mat& frame, DETECTIONSV2& detectionsv2);    
25 |     void sort(vector<DetectBox>& dets);
26 |     void sort(DETECTIONS& detections);
27 |     void init();
28 | 
29 | private:
30 |     std::string enginePath;
31 |     int batchSize;
32 |     int featureDim;
33 |     cv::Size imgShape;
34 |     float confThres;
35 |     float nmsThres;
36 |     int maxBudget;
37 |     float maxCosineDist;
38 | 
39 | private:
40 |     vector<RESULT_DATA> result;
41 |     vector<std::pair<CLSCONF, DETECTBOX>> results;
42 |     tracker* objTracker;
43 |     FeatureTensor* featureExtractor;
44 |     ILogger* gLogger;
45 |     int gpuID;
46 | };
47 | 
48 | #endif  //deepsort.h
49 | 


--------------------------------------------------------------------------------
/include/nn_matching.h:
--------------------------------------------------------------------------------
 1 | #ifndef NN_MATCHING_H
 2 | #define NN_MATCHING_H
 3 | 
 4 | #include "datatype.h"
 5 | 
 6 | #include <map>
 7 | 
 8 | //A tool to calculate distance;
 9 | class NearNeighborDisMetric{
10 | public:
11 |     enum METRIC_TYPE{euclidean=1, cosine};
12 |     NearNeighborDisMetric(METRIC_TYPE metric,
13 |             float matching_threshold,
14 |             int budget);
15 |     DYNAMICM distance(const FEATURESS& features, const std::vector<int> &targets);
16 |     //    void partial_fit(FEATURESS& features, std::vector<int> targets, std::vector<int> active_targets);
17 |     void partial_fit(std::vector<TRACKER_DATA>& tid_feats, std::vector<int>& active_targets);
18 |     float mating_threshold;
19 | 
20 | private:
21 |     typedef Eigen::VectorXf (NearNeighborDisMetric::*PTRFUN)(const FEATURESS&, const FEATURESS&);
22 |     Eigen::VectorXf _nncosine_distance(const FEATURESS& x, const FEATURESS& y);
23 |     Eigen::VectorXf _nneuclidean_distance(const FEATURESS& x, const FEATURESS& y);
24 | 
25 |     Eigen::MatrixXf _pdist(const FEATURESS& x, const FEATURESS& y);
26 |     Eigen::MatrixXf _cosine_distance(const FEATURESS & a, const FEATURESS& b, bool data_is_normalized = false);
27 | private:
28 |     PTRFUN _metric;
29 |     int budget;
30 |     std::map<int, FEATURESS > samples;
31 | };
32 | 
33 | #endif // NN_MATCHING_H
34 | 


--------------------------------------------------------------------------------
/CMakeLists_deepsort-tensorrt_win10.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.6)
 2 | project(deepsort)
 3 | 
 4 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 5 | set(CMAKE_BUILD_TYPE Release)
 6 | set(CUDA_BIN_PATH C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.1)	#1.修改为自己的cuda路径
 7 | set(TRT_DIR "D:\\lbq\\TensorRT-7.2.3.4")  #2.修改为自己的tensorRT路径
 8 | set(TRT_INCLUDE_DIRS ${TRT_DIR}\\include) #3.修改为自己的tensorRT头文件路径
 9 | set(TRT_LIB_DIRS ${TRT_DIR}\\lib) #4.修改为自己的tensorRT库文件路径
10 | set(Eigen3_PATH D:\\lbq\\eigen) #5.修改为自己的Eigen路径
11 | option(CUDA_USE_STATIC_CUDA_RUNTIME OFF)
12 | find_package(OpenCV REQUIRED)
13 | find_package(CUDA REQUIRED)
14 | 
15 | 
16 | enable_language(CUDA)
17 | include_directories(
18 |     ${CUDA_INCLUDE_DIRS}
19 |     ${OpenCV_INCLUDE_DIRS}
20 | 	${TRT_INCLUDE_DIRS}
21 | 	${Eigen3_PATH}
22 |     ${PROJECT_SOURCE_DIR}/include
23 | )
24 | 
25 | # tensorRT
26 | link_directories(${TRT_LIB_DIRS})
27 | link_directories(${OpenCV_LIB_DIRS})
28 | 
29 | aux_source_directory(${PROJECT_SOURCE_DIR}/src SRC_DIR)
30 | 
31 | # ===== deepsort =====
32 | add_library(deepsort STATIC ${SRC_DIR})
33 | target_link_libraries(deepsort 
34 |     ${CUDA_LIBRARIES} ${OpenCV_LIBS} 
35 |     cudart nvinfer nvonnxparser
36 | )
37 | 
38 | # ===== onnx2engine =====
39 | add_executable(onnx2engine ${PROJECT_SOURCE_DIR}/onnx2engine.cpp)
40 | target_link_libraries(onnx2engine
41 |     ${CUDA_LIBRARIES}
42 |     cudart nvinfer nvonnxparser deepsort
43 | )
44 | 
45 | # ===== demo =====
46 | add_executable(demo ${PROJECT_SOURCE_DIR}/demo.cpp)
47 | target_link_libraries(demo 
48 |     ${CUDA_LIBRARIES} ${OpenCV_LIBS} 
49 |     cudart nvinfer nvonnxparser deepsort
50 | )
51 | 
52 | 
53 | 


--------------------------------------------------------------------------------
/exportOnnx.py:
--------------------------------------------------------------------------------
 1 | 
 2 | import os
 3 | import cv2
 4 | import time
 5 | import argparse
 6 | import torch
 7 | import numpy as np
 8 | 
 9 | from deep_sort import build_tracker
10 | from utils.draw import draw_boxes
11 | from utils.parser import get_config
12 | 
13 | from tqdm import tqdm
14 | 
15 | if __name__ == '__main__':
16 |     parser = argparse.ArgumentParser()
17 |     parser.add_argument("--config_deepsort", type=str, default="./configs/deep_sort.yaml", help='Configure tracker')
18 |     parser.add_argument("--cpu", dest="use_cuda", action="store_false", default=True, help='Run in CPU')
19 |     args = parser.parse_args()
20 | 
21 |     cfg = get_config()
22 |     cfg.merge_from_file(args.config_deepsort)
23 |     use_cuda = args.use_cuda and torch.cuda.is_available()
24 |     torch.set_grad_enabled(False)
25 |     model = build_tracker(cfg, use_cuda=False)
26 | 
27 |     model.reid = True
28 |     model.extractor.net.eval()
29 | 
30 |     device = 'cuda'
31 |     output_onnx = 'deepsort.onnx'
32 |     # ------------------------ export -----------------------------
33 |     print("==> Exporting model to ONNX format at '{}'".format(output_onnx))
34 |     input_names = ['input']
35 |     output_names = ['output']
36 | 
37 |     input_tensor = torch.randn(1, 3, 128, 64, device=device)
38 | 
39 |     torch.onnx.export(model.extractor.net.cuda(), input_tensor, output_onnx, export_params=True, verbose=False,
40 |                       input_names=input_names, output_names=output_names, opset_version=10,
41 |                       do_constant_folding=True,
42 |                       dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}})
43 | 


--------------------------------------------------------------------------------
/include/linear_assignment.h:
--------------------------------------------------------------------------------
 1 | #ifndef LINEAR_ASSIGNMENT_H
 2 | #define LINEAR_ASSIGNMENT_H
 3 | 
 4 | #include "datatype.h"
 5 | #include "tracker.h"
 6 | 
 7 | #define INFTY_COST 1e5
 8 | class tracker;
 9 | //for matching;
10 | class linear_assignment
11 | {
12 |     linear_assignment();
13 |     linear_assignment(const linear_assignment& );
14 |     linear_assignment& operator=(const linear_assignment&);
15 |     static linear_assignment* instance;
16 | 
17 | public:
18 |     static linear_assignment* getInstance();
19 |     TRACHER_MATCHD matching_cascade(tracker* distance_metric,
20 |             tracker::GATED_METRIC_FUNC distance_metric_func,
21 |             float max_distance,
22 |             int cascade_depth,
23 |             std::vector<Track>& tracks,
24 |             const DETECTIONS& detections,
25 |             std::vector<int> &track_indices,
26 |             std::vector<int> detection_indices = std::vector<int>());
27 |     TRACHER_MATCHD min_cost_matching(
28 |             tracker* distance_metric,
29 |             tracker::GATED_METRIC_FUNC distance_metric_func,
30 |             float max_distance,
31 |             std::vector<Track>& tracks,
32 |             const DETECTIONS& detections,
33 |             std::vector<int>& track_indices,
34 |             std::vector<int>& detection_indices);
35 |     DYNAMICM gate_cost_matrix(
36 |             KalmanFilter* kf,
37 |             DYNAMICM& cost_matrix,
38 |             std::vector<Track>& tracks,
39 |             const DETECTIONS& detections,
40 |             const std::vector<int>& track_indices,
41 |             const std::vector<int>& detection_indices,
42 |             float gated_cost = INFTY_COST,
43 |             bool only_position = false);
44 | };
45 | 
46 | #endif // LINEAR_ASSIGNMENT_H
47 | 


--------------------------------------------------------------------------------
/include/featuretensor.h:
--------------------------------------------------------------------------------
 1 | #ifndef FEATURETENSOR_H
 2 | #define FEATURETENSOR_H
 3 | 
 4 | #include <iostream>
 5 | #include <opencv2/opencv.hpp>
 6 | #include <vector>
 7 | #include <NvInfer.h>
 8 | #include <NvOnnxParser.h>
 9 | #include "model.hpp"
10 | #include "datatype.h"
11 | #include "cuda_runtime_api.h"
12 | 
13 | using std::vector;
14 | using nvinfer1::ILogger;
15 | 
16 | class FeatureTensor {
17 | public:
18 |     FeatureTensor(const int maxBatchSize, const cv::Size imgShape, const int featureDim, int gpuID, ILogger* gLogger);
19 |     ~FeatureTensor();
20 | 
21 | public:
22 |     bool getRectsFeature(const cv::Mat& img, DETECTIONS& det);
23 |     bool getRectsFeature(DETECTIONS& det);
24 |     void loadEngine(std::string enginePath);
25 |     void loadOnnx(std::string onnxPath);
26 |     int getResult(float*& buffer);
27 |     void doInference(vector<cv::Mat>& imgMats);
28 | 
29 | private:
30 |     void initResource();
31 |     void doInference(float* inputBuffer, float* outputBuffer);
32 |     void mat2stream(vector<cv::Mat>& imgMats, float* stream);
33 |     void stream2det(float* stream, DETECTIONS& det);
34 | 
35 | private:
36 |     nvinfer1::IRuntime* runtime;
37 |     nvinfer1::ICudaEngine* engine;
38 |     nvinfer1::IExecutionContext* context;
39 |     const int maxBatchSize;
40 |     const cv::Size imgShape;
41 |     const int featureDim;
42 | 
43 | private:
44 |     int curBatchSize;
45 |     const int inputStreamSize, outputStreamSize;
46 |     bool initFlag;
47 |     float* const inputBuffer;
48 |     float* const outputBuffer;
49 |     int inputIndex, outputIndex;
50 |     void* buffers[2];
51 |     cudaStream_t cudaStream;
52 |     // BGR format
53 |     float means[3], std[3];
54 |     const std::string inputName, outputName;
55 |     ILogger* gLogger;
56 | };
57 | 
58 | #endif
59 | 


--------------------------------------------------------------------------------
/include/tracker.h:
--------------------------------------------------------------------------------
 1 | #ifndef TRACKER_H
 2 | #define TRACKER_H
 3 | 
 4 | 
 5 | #include <vector>
 6 | 
 7 | #include "kalmanfilter.h"
 8 | #include "track.h"
 9 | #include "model.hpp"
10 | 
11 | using namespace std;
12 | 
13 | class NearNeighborDisMetric;
14 | 
15 | class tracker
16 | {
17 | public:
18 |     NearNeighborDisMetric* metric;
19 |     float max_iou_distance;
20 |     int max_age;
21 |     int n_init;
22 | 
23 |     KalmanFilter* kf;
24 | 
25 |     int _next_idx;
26 | public:
27 |     std::vector<Track> tracks;
28 |     tracker(/*NearNeighborDisMetric* metric,*/
29 |     		float max_cosine_distance, int nn_budget,
30 |             float max_iou_distance = 0.7,
31 |             int max_age = 70, int n_init=3);
32 |     void predict();
33 |     void update(const DETECTIONS& detections);
34 |     void update(const DETECTIONSV2& detectionsv2);
35 |     typedef DYNAMICM (tracker::* GATED_METRIC_FUNC)(
36 |             std::vector<Track>& tracks,
37 |             const DETECTIONS& dets,
38 |             const std::vector<int>& track_indices,
39 |             const std::vector<int>& detection_indices);
40 | private:    
41 |     void _match(const DETECTIONS& detections, TRACHER_MATCHD& res);
42 |     void _initiate_track(const DETECTION_ROW& detection);
43 |     void _initiate_track(const DETECTION_ROW& detection, CLSCONF clsConf);
44 | public:
45 |     DYNAMICM gated_matric(
46 |             std::vector<Track>& tracks,
47 |             const DETECTIONS& dets,
48 |             const std::vector<int>& track_indices,
49 |             const std::vector<int>& detection_indices);
50 |     DYNAMICM iou_cost(
51 |             std::vector<Track>& tracks,
52 |             const DETECTIONS& dets,
53 |             const std::vector<int>& track_indices,
54 |             const std::vector<int>& detection_indices);
55 |     Eigen::VectorXf iou(DETECTBOX& bbox,
56 |             DETECTBOXSS &candidates);
57 | };
58 | 
59 | #endif // TRACKER_H
60 | 


--------------------------------------------------------------------------------
/include/datatype.h:
--------------------------------------------------------------------------------
 1 | #ifndef DATATYPE_H
 2 | #define DATATYPE_H
 3 | 
 4 | typedef struct DetectBox {
 5 |     DetectBox(float x1=0, float y1=0, float x2=0, float y2=0, 
 6 |             float confidence=0, float classID=-1, float trackID=-1) {
 7 |         this->x1 = x1;
 8 |         this->y1 = y1;
 9 |         this->x2 = x2;
10 |         this->y2 = y2;
11 |         this->confidence = confidence;
12 |         this->classID = classID;
13 |         this->trackID = trackID;
14 |     }
15 |     float x1, y1, x2, y2;
16 |     float confidence;
17 |     float classID;
18 |     float trackID;
19 | } DetectBox;
20 | 
21 | #endif // DATATYPE_H
22 | 
23 | #ifndef DEEPSORTDATATYPE_H
24 | #define DEEPSORTDATATYPE_H
25 | 
26 | #include <cstddef>
27 | #include <vector>
28 | #include <Eigen/Core>
29 | #include <Eigen/Dense>
30 | typedef struct CLSCONF {
31 |     CLSCONF() {
32 |         this->cls = -1;
33 |         this->conf = -1;
34 |     }
35 |     CLSCONF(int cls, float conf) {
36 |         this->cls = cls;
37 |         this->conf = conf;
38 |     }
39 |     int cls;
40 |     float conf;
41 | } CLSCONF;
42 | 
43 | typedef Eigen::Matrix<float, 1, 4, Eigen::RowMajor> DETECTBOX;
44 | typedef Eigen::Matrix<float, -1, 4, Eigen::RowMajor> DETECTBOXSS;
45 | typedef Eigen::Matrix<float, 1, 256, Eigen::RowMajor> FEATURE;
46 | typedef Eigen::Matrix<float, Eigen::Dynamic, 256, Eigen::RowMajor> FEATURESS;
47 | //typedef std::vector<FEATURE> FEATURESS;
48 | 
49 | //Kalmanfilter
50 | //typedef Eigen::Matrix<float, 8, 8, Eigen::RowMajor> KAL_FILTER;
51 | typedef Eigen::Matrix<float, 1, 8, Eigen::RowMajor> KAL_MEAN;
52 | typedef Eigen::Matrix<float, 8, 8, Eigen::RowMajor> KAL_COVA;
53 | typedef Eigen::Matrix<float, 1, 4, Eigen::RowMajor> KAL_HMEAN;
54 | typedef Eigen::Matrix<float, 4, 4, Eigen::RowMajor> KAL_HCOVA;
55 | using KAL_DATA = std::pair<KAL_MEAN, KAL_COVA>;
56 | using KAL_HDATA = std::pair<KAL_HMEAN, KAL_HCOVA>;
57 | 
58 | //main
59 | using RESULT_DATA = std::pair<int, DETECTBOX>;
60 | 
61 | //tracker:
62 | using TRACKER_DATA = std::pair<int, FEATURESS>;
63 | using MATCH_DATA = std::pair<int, int>;
64 | typedef struct t{
65 |     std::vector<MATCH_DATA> matches;
66 |     std::vector<int> unmatched_tracks;
67 |     std::vector<int> unmatched_detections;
68 | }TRACHER_MATCHD;
69 | 
70 | //linear_assignment:
71 | typedef Eigen::Matrix<float, -1, -1, Eigen::RowMajor> DYNAMICM;
72 | 
73 | #endif //DEEPSORTDATATYPE_H


--------------------------------------------------------------------------------
/src/deepsortenginegenerator.cpp:
--------------------------------------------------------------------------------
 1 | #include "deepsortenginegenerator.h"
 2 | #include "assert.h"
 3 | #include <memory.h> 
 4 | #include <fstream>
 5 | 
 6 | DeepSortEngineGenerator::DeepSortEngineGenerator(ILogger* gLogger) {
 7 |     this->gLogger = gLogger;
 8 | }
 9 | 
10 | DeepSortEngineGenerator::~DeepSortEngineGenerator() {
11 | 
12 | }
13 | 
14 | void DeepSortEngineGenerator::setFP16(bool state) {
15 |     this->useFP16 = state;
16 | }
17 | 
18 | void DeepSortEngineGenerator::createEngine(std::string onnxPath, std::string enginePath) {
19 |     // Load onnx model
20 |     auto builder = createInferBuilder(*gLogger);
21 |     assert(builder != nullptr);
22 |     const auto explicitBatch = 1U << static_cast<uint32_t>(NetworkDefinitionCreationFlag::kEXPLICIT_BATCH);
23 |     auto network = builder->createNetworkV2(explicitBatch);
24 |     assert(network != nullptr);
25 |     auto config = builder->createBuilderConfig();
26 |     assert(config != nullptr);
27 | 
28 |     auto profile = builder->createOptimizationProfile();
29 |     Dims dims = Dims4{1, 3, IMG_HEIGHT, IMG_WIDTH};
30 |     profile->setDimensions(INPUT_NAME.c_str(),
31 |                 OptProfileSelector::kMIN, Dims4{1, dims.d[1], dims.d[2], dims.d[3]});
32 |     profile->setDimensions(INPUT_NAME.c_str(),
33 |                 OptProfileSelector::kOPT, Dims4{MAX_BATCH_SIZE, dims.d[1], dims.d[2], dims.d[3]});
34 |     profile->setDimensions(INPUT_NAME.c_str(),
35 |                 OptProfileSelector::kMAX, Dims4{MAX_BATCH_SIZE, dims.d[1], dims.d[2], dims.d[3]});
36 |     config->addOptimizationProfile(profile);
37 | 
38 |     nvonnxparser::IParser* parser = nvonnxparser::createParser(*network, *gLogger);
39 |     assert(parser != nullptr);
40 |     auto parsed = parser->parseFromFile(onnxPath.c_str(), static_cast<int>(ILogger::Severity::kWARNING));
41 |     assert(parsed);
42 |     if (useFP16) config->setFlag(BuilderFlag::kFP16);
43 |     config->setMaxWorkspaceSize(1 << 20);
44 |     ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);
45 | 
46 |     // Serialize model and save engine
47 |     IHostMemory* modelStream = engine->serialize();
48 |     std::string serializeStr;
49 |     std::ofstream serializeOutputStream;
50 |     serializeStr.resize(modelStream->size());
51 |     memcpy((void*)serializeStr.data(), modelStream->data(), modelStream->size());
52 |     serializeOutputStream.open(enginePath, std::ios::binary);
53 |     serializeOutputStream << serializeStr;
54 |     serializeOutputStream.close();
55 | }
56 | 


--------------------------------------------------------------------------------
/include/track.h:
--------------------------------------------------------------------------------
 1 | #ifndef TRACK_H
 2 | #define TRACK_H
 3 | 
 4 | 
 5 | #include "kalmanfilter.h"
 6 | #include "datatype.h"
 7 | #include "model.hpp"
 8 | 
 9 | class Track
10 | {
11 |     /*"""
12 |     A single target track with state space `(x, y, a, h)` and associated
13 |     velocities, where `(x, y)` is the center of the bounding box, `a` is the
14 |     aspect ratio and `h` is the height.
15 | 
16 |     Parameters
17 |     ----------
18 |     mean : ndarray
19 |         Mean vector of the initial state distribution.
20 |     covariance : ndarray
21 |         Covariance matrix of the initial state distribution.
22 |     track_id : int
23 |         A unique track identifier.
24 |     n_init : int
25 |         Number of consecutive detections before the track is confirmed. The
26 |         track state is set to `Deleted` if a miss occurs within the first
27 |         `n_init` frames.
28 |     max_age : int
29 |         The maximum number of consecutive misses before the track state is
30 |         set to `Deleted`.
31 |     feature : Optional[ndarray]
32 |         Feature vector of the detection this track originates from. If not None,
33 |         this feature is added to the `features` cache.
34 | 
35 |     Attributes
36 |     ----------
37 |     mean : ndarray
38 |         Mean vector of the initial state distribution.
39 |     covariance : ndarray
40 |         Covariance matrix of the initial state distribution.
41 |     track_id : int
42 |         A unique track identifier.
43 |     hits : int
44 |         Total number of measurement updates.
45 |     age : int
46 |         Total number of frames since first occurance.
47 |     time_since_update : int
48 |         Total number of frames since last measurement update.
49 |     state : TrackState
50 |         The current track state.
51 |     features : List[ndarray]
52 |         A cache of features. On each measurement update, the associated feature
53 |         vector is added to this list.
54 | 
55 |     """*/
56 |     enum TrackState {Tentative = 1, Confirmed, Deleted};
57 | 
58 | public:
59 |     Track(KAL_MEAN& mean, KAL_COVA& covariance, int track_id,
60 |           int n_init, int max_age, const FEATURE& feature);
61 |     Track(KAL_MEAN& mean, KAL_COVA& covariance, int track_id,
62 |           int n_init, int max_age, const FEATURE& feature, int cls, float conf);
63 |     void predit(KalmanFilter* kf);
64 |     void update(KalmanFilter* const kf, const DETECTION_ROW &detection);
65 |     void update(KalmanFilter* const kf, const DETECTION_ROW & detection, CLSCONF pair_det);
66 |     void mark_missed();
67 |     bool is_confirmed();
68 |     bool is_deleted();
69 |     bool is_tentative();
70 |     DETECTBOX to_tlwh();
71 |     int time_since_update;
72 |     int track_id;
73 |     FEATURESS features;
74 |     KAL_MEAN mean;
75 |     KAL_COVA covariance;
76 | 
77 |     int hits;
78 |     int age;
79 |     int _n_init;
80 |     int _max_age;
81 |     TrackState state;
82 | 
83 |     int cls;
84 |     float conf;
85 | private:
86 |     void featuresAppendOne(const FEATURE& f);
87 | };
88 | 
89 | #endif // TRACK_H
90 | 


--------------------------------------------------------------------------------
/demo.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <fstream>
  3 | #include <opencv2/opencv.hpp>
  4 | #include <vector>
  5 | #include "deepsort.h"
  6 | #include "logging.h"
  7 | #include <ctime>
  8 | 
  9 | using std::vector;
 10 | 
 11 | static Logger gLogger;
 12 | 
 13 | void showDetection(cv::Mat& img, std::vector<DetectBox>& boxes) {
 14 |     cv::Mat temp = img.clone();
 15 |     for (auto box : boxes) {
 16 |         cv::Point lt(box.x1, box.y1);
 17 |         cv::Point br(box.x2, box.y2);
 18 |         cv::rectangle(temp, lt, br, cv::Scalar(255, 0, 0), 1);
 19 |         std::string lbl = cv::format("ID:%d_C:%d_CONF:%.2f", (int)box.trackID, (int)box.classID, box.confidence);
 20 |         cv::putText(temp, lbl, lt, cv::FONT_HERSHEY_COMPLEX, 0.8, cv::Scalar(0,255,0));
 21 |     }
 22 |     cv::imshow("img", temp);
 23 |     cv::waitKey(1);
 24 | }
 25 | 
 26 | class Tester {
 27 | public:
 28 |     Tester(string modelPath) {
 29 |         allDetections.clear();
 30 |         out.clear();
 31 |         DS = new DeepSort(modelPath, 128, 256, 0, &gLogger);
 32 |     }
 33 |     ~Tester() {
 34 |     }
 35 | 
 36 | public:
 37 | 
 38 |     void split(const std::string& s, vector<std::string>& token, char delim=' ') {
 39 |         token.clear();
 40 |         auto string_find_first_not = [s, delim](size_t pos = 0) -> size_t {
 41 |             for (size_t i = pos; i < s.size(); ++i)
 42 |                 if (s[i] != delim) return i;
 43 |             return string::npos;
 44 |         };
 45 |         size_t lastPos = string_find_first_not(0);
 46 |         size_t pos = s.find(delim, lastPos);
 47 |         while (lastPos != string::npos) {
 48 |             token.emplace_back(s.substr(lastPos, pos-lastPos));
 49 |             lastPos = string_find_first_not(pos);
 50 |             pos = s.find(delim, lastPos);
 51 |         }
 52 |     }
 53 | 
 54 |     void loadDetections(std::string txtPath) {
 55 |         //fstream f(filePath, ios::in);
 56 |         this->txtPath = txtPath;
 57 |         ifstream inFile;
 58 |         inFile.open(txtPath, ios::binary);
 59 |         std::string temp;
 60 |         vector<std::string> token;
 61 |         while (getline(inFile, temp)) {
 62 |             // std::cout << temp << std::endl;
 63 |             split(temp, token, ' ');
 64 |             int frame = atoi(token[0].c_str());
 65 |             int c     = atoi(token[1].c_str());
 66 |             int x     = atoi(token[2].c_str());
 67 |             int y     = atoi(token[3].c_str());
 68 |             int w     = atoi(token[4].c_str());
 69 |             int h     = atoi(token[5].c_str());
 70 |             float con= atof(token[6].c_str());     
 71 |             while (allDetections.size() <= frame) {
 72 |                 vector<DetectBox> t;
 73 |                 allDetections.push_back(t);
 74 |             }
 75 |             DetectBox dd(x-w/2, y-h/2, x+w/2, y+h/2, con, c);
 76 |             allDetections[frame].push_back(dd);
 77 |         }
 78 |         allDetections.pop_back();
 79 |     }
 80 | 
 81 |     void run() {
 82 |         cv::namedWindow("DeepSortTest");
 83 |         int i = 1;
 84 |         cv::Mat whiteBoard(1080, 1920, CV_8UC3, cv::Scalar::all(0));
 85 |         for (vector<DetectBox> d : allDetections) {
 86 |             cv::Mat img_rgb;
 87 |             cv::cvtColor(whiteBoard, img_rgb, cv::COLOR_BGR2RGB);
 88 | 
 89 |             DS->sort(img_rgb, d);
 90 | 
 91 |             showDetection(whiteBoard, d);
 92 |         }
 93 |         cv::destroyAllWindows();
 94 |     }
 95 | 
 96 | private:
 97 |     vector<vector<DetectBox>> allDetections;
 98 |     vector<DetectBox> out;
 99 |     std::string txtPath;
100 |     DeepSort* DS;
101 | };
102 | 
103 | int main(int argc, char** argv) {
104 |     if (argc < 3) {
105 |         std::cout << "./demo [input model path] [input txt path]" << std::endl;
106 |         return -1;
107 |     }
108 |     Tester* test = new Tester(argv[1]);
109 |     test->loadDetections(argv[2]);
110 |     test->run();
111 | }
112 | 


--------------------------------------------------------------------------------
/src/track.cpp:
--------------------------------------------------------------------------------
  1 | #include "track.h"
  2 | #include <iostream>
  3 | 
  4 | Track::Track(KAL_MEAN & mean, KAL_COVA & covariance, int track_id, int n_init, int max_age, const FEATURE & feature)
  5 | {
  6 |     this->mean = mean;
  7 |     this->covariance = covariance;
  8 |     this->track_id = track_id;
  9 |     this->hits = 1;
 10 |     this->age = 1;
 11 |     this->time_since_update = 0;
 12 |     this->state = TrackState::Tentative;
 13 |     features = FEATURESS(1, 256);
 14 |     features.row(0) = feature;  //features.rows() must = 0;
 15 | 
 16 |     this->_n_init = n_init;
 17 |     this->_max_age = max_age;
 18 | }
 19 | 
 20 | Track::Track(KAL_MEAN & mean, KAL_COVA & covariance, int track_id, int n_init, int max_age, const FEATURE & feature, int cls, float conf)
 21 | {
 22 |     this->mean = mean;
 23 |     this->covariance = covariance;
 24 |     this->track_id = track_id;
 25 |     this->hits = 1;
 26 |     this->age = 1;
 27 |     this->time_since_update = 0;
 28 |     this->state = TrackState::Tentative;
 29 |     features = FEATURESS(1, 256);
 30 |     features.row(0) = feature;  //features.rows() must = 0;
 31 | 
 32 |     this->_n_init = n_init;
 33 |     this->_max_age = max_age;
 34 | 
 35 |     this->cls = cls;
 36 |     this->conf = conf;
 37 | }
 38 | 
 39 | void Track::predit(KalmanFilter * kf)
 40 | {
 41 |     /*Propagate the state distribution to the current time step using a
 42 |        Kalman filter prediction step.
 43 | 
 44 |        Parameters
 45 |        ----------
 46 |        kf : kalman_filter.KalmanFilterd
 47 |        The Kalman filter.
 48 |      */
 49 | 
 50 |     kf->predict(this->mean, this->covariance);
 51 | 
 52 | 
 53 |     this->age += 1;
 54 |     this->time_since_update += 1;
 55 | }
 56 | 
 57 | void Track::update(KalmanFilter * const kf, const DETECTION_ROW & detection)
 58 | {
 59 |     KAL_DATA pa = kf->update(this->mean, this->covariance, detection.to_xyah());
 60 |     this->mean = pa.first;
 61 |     this->covariance = pa.second;
 62 | 
 63 |     featuresAppendOne(detection.feature);
 64 |     //    this->features.row(features.rows()) = detection.feature;
 65 |     this->hits += 1;
 66 |     this->time_since_update = 0;
 67 |     if (this->state == TrackState::Tentative && this->hits >= this->_n_init) {
 68 |         this->state = TrackState::Confirmed;
 69 |     }
 70 | }
 71 | 
 72 | void Track::update(KalmanFilter * const kf, const DETECTION_ROW & detection, CLSCONF pair_det)
 73 | {
 74 |     KAL_DATA pa = kf->update(this->mean, this->covariance, detection.to_xyah());
 75 |     this->mean = pa.first;
 76 |     this->covariance = pa.second;
 77 | 
 78 |     featuresAppendOne(detection.feature);
 79 |     //    this->features.row(features.rows()) = detection.feature;
 80 |     this->hits += 1;
 81 |     this->time_since_update = 0;
 82 |     if (this->state == TrackState::Tentative && this->hits >= this->_n_init) {
 83 |         this->state = TrackState::Confirmed;
 84 |     }
 85 |     this->cls = pair_det.cls;
 86 |     this->conf = pair_det.conf;
 87 | }
 88 | 
 89 | void Track::mark_missed()
 90 | {
 91 |     if (this->state == TrackState::Tentative) {
 92 |         this->state = TrackState::Deleted;
 93 |     } else if (this->time_since_update > this->_max_age) {
 94 |         this->state = TrackState::Deleted;
 95 |     }
 96 | }
 97 | 
 98 | bool Track::is_confirmed()
 99 | {
100 |     return this->state == TrackState::Confirmed;
101 | }
102 | 
103 | bool Track::is_deleted()
104 | {
105 |     return this->state == TrackState::Deleted;
106 | }
107 | 
108 | bool Track::is_tentative()
109 | {
110 |     return this->state == TrackState::Tentative;
111 | }
112 | 
113 | DETECTBOX Track::to_tlwh()
114 | {
115 |     DETECTBOX ret = mean.leftCols(4);
116 |     ret(2) *= ret(3);
117 |     ret.leftCols(2) -= (ret.rightCols(2) / 2);
118 |     return ret;
119 | }
120 | 
121 | void Track::featuresAppendOne(const FEATURE & f)
122 | {
123 |     int size = this->features.rows();
124 |     FEATURESS newfeatures = FEATURESS(size + 1, 256);
125 |     newfeatures.block(0, 0, size, 256) = this->features;
126 |     newfeatures.row(size) = f;
127 |     features = newfeatures;
128 | }
129 | 


--------------------------------------------------------------------------------
/src/deepsort.cpp:
--------------------------------------------------------------------------------
  1 | #include "deepsort.h"
  2 | 
  3 | DeepSort::DeepSort(std::string modelPath, int batchSize, int featureDim, int gpuID, ILogger* gLogger) {
  4 |     this->gpuID = gpuID;
  5 |     this->enginePath = modelPath;
  6 |     this->batchSize = batchSize;
  7 |     this->featureDim = featureDim;
  8 |     this->imgShape = cv::Size(64, 128);
  9 |     this->maxBudget = 100;
 10 |     this->maxCosineDist = 0.2;
 11 |     this->gLogger = gLogger;
 12 |     init();
 13 | }
 14 | 
 15 | void DeepSort::init() {
 16 |     objTracker = new tracker(maxCosineDist, maxBudget);
 17 |     featureExtractor = new FeatureTensor(batchSize, imgShape, featureDim, gpuID, gLogger);
 18 |     int ret = enginePath.find(".onnx");
 19 |     if (ret != -1)
 20 |         featureExtractor->loadOnnx(enginePath);
 21 |     else
 22 |         featureExtractor->loadEngine(enginePath);
 23 | }
 24 | 
 25 | DeepSort::~DeepSort() {
 26 |     delete objTracker;
 27 | }
 28 | 
 29 | void DeepSort::sort(cv::Mat& frame, vector<DetectBox>& dets) {
 30 |     // preprocess Mat -> DETECTION
 31 |     DETECTIONS detections;
 32 |     vector<CLSCONF> clsConf;
 33 |     
 34 |     for (DetectBox i : dets) {
 35 |         DETECTBOX box(i.x1, i.y1, i.x2-i.x1, i.y2-i.y1);
 36 |         DETECTION_ROW d;
 37 |         d.tlwh = box;
 38 |         d.confidence = i.confidence;
 39 |         detections.push_back(d);
 40 |         clsConf.push_back(CLSCONF((int)i.classID, i.confidence));
 41 |     }
 42 |     result.clear();
 43 |     results.clear();
 44 |     if (detections.size() > 0) {
 45 |         DETECTIONSV2 detectionsv2 = make_pair(clsConf, detections);
 46 |         sort(frame, detectionsv2);
 47 |     }
 48 |     // postprocess DETECTION -> Mat
 49 |     dets.clear();
 50 |     for (auto r : result) {
 51 |         DETECTBOX i = r.second;
 52 |         DetectBox b(i(0), i(1), i(2)+i(0), i(3)+i(1), 1.);
 53 |         b.trackID = (float)r.first;
 54 |         dets.push_back(b);
 55 |     }
 56 |     for (int i = 0; i < results.size(); ++i) {
 57 |         CLSCONF c = results[i].first;
 58 |         dets[i].classID = c.cls;
 59 |         dets[i].confidence = c.conf;
 60 |     }
 61 | }
 62 | 
 63 | 
 64 | void DeepSort::sort(cv::Mat& frame, DETECTIONS& detections) {
 65 |     bool flag = featureExtractor->getRectsFeature(frame, detections);
 66 |     if (flag) {
 67 |         objTracker->predict();
 68 |         objTracker->update(detections);
 69 |         //result.clear();
 70 |         for (Track& track : objTracker->tracks) {
 71 |             if (!track.is_confirmed() || track.time_since_update > 1)
 72 |                 continue;
 73 |             result.push_back(make_pair(track.track_id, track.to_tlwh()));
 74 |         }
 75 |     }
 76 | }
 77 | 
 78 | void DeepSort::sort(cv::Mat& frame, DETECTIONSV2& detectionsv2) {
 79 |     std::vector<CLSCONF>& clsConf = detectionsv2.first;
 80 |     DETECTIONS& detections = detectionsv2.second;
 81 |     bool flag = featureExtractor->getRectsFeature(frame, detections);
 82 |     if (flag) {
 83 |         objTracker->predict();
 84 |         objTracker->update(detectionsv2);
 85 |         result.clear();
 86 |         results.clear();
 87 |         for (Track& track : objTracker->tracks) {
 88 |             if (!track.is_confirmed() || track.time_since_update > 1)
 89 |                 continue;
 90 |             result.push_back(make_pair(track.track_id, track.to_tlwh()));
 91 |             results.push_back(make_pair(CLSCONF(track.cls, track.conf) ,track.to_tlwh()));
 92 |         }
 93 |     }
 94 | }
 95 | 
 96 | void DeepSort::sort(vector<DetectBox>& dets) {
 97 |     DETECTIONS detections;
 98 |     for (DetectBox i : dets) {
 99 |         DETECTBOX box(i.x1, i.y1, i.x2-i.x1, i.y2-i.y1);
100 |         DETECTION_ROW d;
101 |         d.tlwh = box;
102 |         d.confidence = i.confidence;
103 |         detections.push_back(d);
104 |     }
105 |     if (detections.size() > 0)
106 |         sort(detections);
107 |     dets.clear();
108 |     for (auto r : result) {
109 |         DETECTBOX i = r.second;
110 |         DetectBox b(i(0), i(1), i(2), i(3), 1.);
111 |         b.trackID = r.first;
112 |         dets.push_back(b);
113 |     }
114 | }
115 | 
116 | void DeepSort::sort(DETECTIONS& detections) {
117 |     bool flag = featureExtractor->getRectsFeature(detections);
118 |     if (flag) {
119 |         objTracker->predict();
120 |         objTracker->update(detections);
121 |         result.clear();
122 |         for (Track& track : objTracker->tracks) {
123 |             if (!track.is_confirmed() || track.time_since_update > 1)
124 |                 continue;
125 |             result.push_back(make_pair(track.track_id, track.to_tlwh()));
126 |         }
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/src/kalmanfilter.cpp:
--------------------------------------------------------------------------------
  1 | #include "kalmanfilter.h"
  2 | #include <Eigen/Cholesky>
  3 | #include <iostream>
  4 | 
  5 | const double KalmanFilter::chi2inv95[10] = {
  6 |     0,
  7 |     3.8415,
  8 |     5.9915,
  9 |     7.8147,
 10 |     9.4877,
 11 |     11.070,
 12 |     12.592,
 13 |     14.067,
 14 |     15.507,
 15 |     16.919
 16 | };
 17 | KalmanFilter::KalmanFilter() {
 18 |     int ndim = 4;
 19 |     double dt = 1.;
 20 | 
 21 |     _motion_mat = Eigen::MatrixXf::Identity(8, 8);
 22 |     for(int i = 0; i < ndim; i++) {
 23 |         _motion_mat(i, ndim+i) = dt;
 24 |     }
 25 |     _update_mat = Eigen::MatrixXf::Identity(4, 8);
 26 | 
 27 |     this->_std_weight_position = 1. / 20;
 28 |     this->_std_weight_velocity = 1. / 160;
 29 | }
 30 | 
 31 | KAL_DATA KalmanFilter::initiate(const DETECTBOX& measurement) {
 32 |     DETECTBOX mean_pos = measurement;
 33 |     DETECTBOX mean_vel;
 34 |     for(int i = 0; i < 4; i++) mean_vel(i) = 0;
 35 | 
 36 |     KAL_MEAN mean;
 37 |     for(int i = 0; i < 8; i++){
 38 |         if(i < 4) mean(i) = mean_pos(i);
 39 |         else mean(i) = mean_vel(i - 4);
 40 |     }
 41 | 
 42 |     KAL_MEAN std;
 43 |     std(0) = 2 * _std_weight_position * measurement[3];
 44 |     std(1) = 2 * _std_weight_position * measurement[3];
 45 |     std(2) = 1e-2;
 46 |     std(3) = 2 * _std_weight_position * measurement[3];
 47 |     std(4) = 10 * _std_weight_velocity * measurement[3];
 48 |     std(5) = 10 * _std_weight_velocity * measurement[3];
 49 |     std(6) = 1e-5;
 50 |     std(7) = 10 * _std_weight_velocity * measurement[3];
 51 | 
 52 |     KAL_MEAN tmp = std.array().square();
 53 |     KAL_COVA var = tmp.asDiagonal();
 54 |     return std::make_pair(mean, var);
 55 | }
 56 | 
 57 | void KalmanFilter::predict(KAL_MEAN &mean, KAL_COVA &covariance) {
 58 |     //revise the data;
 59 |     DETECTBOX std_pos;
 60 |     std_pos << _std_weight_position * mean(3),
 61 |             _std_weight_position * mean(3),
 62 |             1e-2,
 63 |             _std_weight_position * mean(3);
 64 |     DETECTBOX std_vel;
 65 |     std_vel << _std_weight_velocity * mean(3),
 66 |             _std_weight_velocity * mean(3),
 67 |             1e-5,
 68 |             _std_weight_velocity * mean(3);
 69 |     KAL_MEAN tmp;
 70 |     tmp.block<1,4>(0,0) = std_pos;
 71 |     tmp.block<1,4>(0,4) = std_vel;
 72 |     tmp = tmp.array().square();
 73 |     KAL_COVA motion_cov = tmp.asDiagonal();
 74 |     KAL_MEAN mean1 = this->_motion_mat * mean.transpose();
 75 |     KAL_COVA covariance1 = this->_motion_mat * covariance *(_motion_mat.transpose());
 76 |     covariance1 += motion_cov;
 77 | 
 78 |     mean = mean1;
 79 |     covariance = covariance1;
 80 | }
 81 | 
 82 | KAL_HDATA KalmanFilter::project(const KAL_MEAN &mean, const KAL_COVA &covariance) {
 83 |     DETECTBOX std;
 84 |     std << _std_weight_position * mean(3), _std_weight_position * mean(3),
 85 |             1e-1, _std_weight_position * mean(3);
 86 |     KAL_HMEAN mean1 = _update_mat * mean.transpose();
 87 |     KAL_HCOVA covariance1 = _update_mat * covariance * (_update_mat.transpose());
 88 |     Eigen::Matrix<float, 4, 4> diag = std.asDiagonal();
 89 |     diag = diag.array().square().matrix();
 90 |     covariance1 += diag;
 91 | //    covariance1.diagonal() << diag;
 92 |     return std::make_pair(mean1, covariance1);
 93 | }
 94 | 
 95 | KAL_DATA
 96 | KalmanFilter::update(
 97 |         const KAL_MEAN &mean,
 98 |         const KAL_COVA &covariance,
 99 |         const DETECTBOX &measurement) {
100 |     KAL_HDATA pa = project(mean, covariance);
101 |     KAL_HMEAN projected_mean = pa.first;
102 |     KAL_HCOVA projected_cov = pa.second;
103 | 
104 |     //chol_factor, lower =
105 |     //scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
106 |     //kalmain_gain =
107 |     //scipy.linalg.cho_solve((cho_factor, lower),
108 |     //np.dot(covariance, self._upadte_mat.T).T,
109 |     //check_finite=False).T
110 |     Eigen::Matrix<float, 4, 8> B = (covariance * (_update_mat.transpose())).transpose();
111 |     Eigen::Matrix<float, 8, 4> kalman_gain = (projected_cov.llt().solve(B)).transpose(); // eg.8x4
112 |     Eigen::Matrix<float, 1, 4> innovation = measurement - projected_mean; //eg.1x4
113 |     auto tmp = innovation*(kalman_gain.transpose());
114 |     KAL_MEAN new_mean = (mean.array() + tmp.array()).matrix();
115 |     KAL_COVA new_covariance = covariance - kalman_gain*projected_cov*(kalman_gain.transpose());
116 |     return std::make_pair(new_mean, new_covariance);
117 | }
118 | 
119 | Eigen::Matrix<float, 1, -1>
120 | KalmanFilter::gating_distance(
121 |         const KAL_MEAN &mean,
122 |         const KAL_COVA &covariance,
123 |         const std::vector<DETECTBOX> &measurements,
124 |         bool only_position) {
125 |     KAL_HDATA pa = this->project(mean, covariance);
126 |     if(only_position) {
127 |         printf("not implement!");
128 |         exit(0);
129 |     }
130 |     KAL_HMEAN mean1 = pa.first;
131 |     KAL_HCOVA covariance1 = pa.second;
132 | 
133 | //    Eigen::Matrix<float, -1, 4, Eigen::RowMajor> d(size, 4);
134 |     DETECTBOXSS d(measurements.size(), 4);
135 |     int pos = 0;
136 |     for(DETECTBOX box:measurements) {        
137 |         d.row(pos++) = box - mean1;
138 |     }
139 |     Eigen::Matrix<float, -1, -1, Eigen::RowMajor> factor = covariance1.llt().matrixL();
140 |     Eigen::Matrix<float, -1, -1> z = factor.triangularView<Eigen::Lower>().solve<Eigen::OnTheRight>(d).transpose();
141 |     auto zz = ((z.array())*(z.array())).matrix();
142 |     auto square_maha = zz.colwise().sum();
143 |     return square_maha;
144 | }
145 | 
146 | 


--------------------------------------------------------------------------------
/src/nn_matching.cpp:
--------------------------------------------------------------------------------
  1 | #include "nn_matching.h"
  2 | #include <iostream>
  3 | 
  4 | using namespace Eigen;
  5 | 
  6 | NearNeighborDisMetric::NearNeighborDisMetric(
  7 |     NearNeighborDisMetric::METRIC_TYPE metric, 
  8 |     float matching_threshold, int budget)
  9 | {
 10 |     if (metric == euclidean) {
 11 |         _metric =
 12 |             &NearNeighborDisMetric::_nneuclidean_distance;
 13 |     } else if (metric == cosine) {
 14 |         _metric =
 15 |             &NearNeighborDisMetric::_nncosine_distance;
 16 |     }
 17 | 
 18 |     this->mating_threshold = matching_threshold;
 19 |     this->budget = budget;
 20 |     this->samples.clear();
 21 | }
 22 | 
 23 | DYNAMICM 
 24 | NearNeighborDisMetric::distance(
 25 |     const FEATURESS & features,
 26 |     const std::vector < int >&targets)
 27 | {
 28 |     DYNAMICM cost_matrix = Eigen::MatrixXf::Zero(targets.size(), features.rows());
 29 |     int idx = 0;
 30 |   for (int target:targets) {
 31 |         cost_matrix.row(idx) = (this->*_metric) (this->samples[target], features);
 32 |         idx++;
 33 |     }
 34 |     return cost_matrix;
 35 | }
 36 | 
 37 | void
 38 |  NearNeighborDisMetric::partial_fit(
 39 |      std::vector <TRACKER_DATA > &tid_feats,
 40 |     std::vector < int >&active_targets)
 41 | {
 42 |     /*python code:
 43 |      * let feature(target_id) append to samples;
 44 |      * && delete not comfirmed target_id from samples.
 45 |      * update samples;
 46 |      */
 47 |   for (TRACKER_DATA & data:tid_feats) {
 48 |         int track_id = data.first;
 49 |         FEATURESS newFeatOne = data.second;
 50 | 
 51 |         if (samples.find(track_id) != samples.end()) {  //append
 52 |             int oldSize = samples[track_id].rows();
 53 |             int addSize = newFeatOne.rows();
 54 |             int newSize = oldSize + addSize;
 55 | 
 56 |             if (newSize <= this->budget) {
 57 |                 FEATURESS newSampleFeatures(newSize, 256);
 58 |                 newSampleFeatures.block(0, 0, oldSize, 256) = samples[track_id];
 59 |                 newSampleFeatures.block(oldSize, 0, addSize, 256) = newFeatOne;
 60 |                 samples[track_id] = newSampleFeatures;
 61 |             } else {
 62 |                 if (oldSize < this->budget) {   //original space is not enough;
 63 |                     FEATURESS newSampleFeatures(this->budget, 256);
 64 |                     if (addSize >= this->budget) {
 65 |                         newSampleFeatures = newFeatOne.block(0, 0, this->budget, 256);
 66 |                     } else {
 67 |                         newSampleFeatures.block(0, 0, this->budget - addSize, 256) =
 68 |                             samples[track_id].block(addSize - 1, 0, this->budget - addSize, 256).eval();
 69 |                         newSampleFeatures.block(this->budget - addSize, 0, addSize,256) = newFeatOne;
 70 |                     }
 71 |                     samples[track_id] = newSampleFeatures;
 72 |                 } else {        //original space is ok;
 73 |                     if (addSize >= this->budget) {
 74 |                         samples[track_id] = newFeatOne.block(0, 0, this->budget, 256);
 75 |                     } else {
 76 |                         samples[track_id].block(0, 0, this->budget - addSize, 256) =
 77 |                             samples[track_id].block(addSize - 1, 0, this->budget - addSize, 256).eval();
 78 |                         samples[track_id].block(this->budget - addSize, 0, addSize, 256) = newFeatOne;
 79 |                     }
 80 |                 }
 81 |             }
 82 |         } else {                //not exit, create new one;
 83 |             samples[track_id] = newFeatOne;
 84 |         }
 85 |     }                           //add features;
 86 | 
 87 |     //erase the samples which not in active_targets;
 88 |     for (std::map < int, FEATURESS >::iterator i = samples.begin(); i != samples.end();) {
 89 |         bool flag = false;
 90 |       for (int j:active_targets) if (j == i->first) { flag = true; break; }
 91 |         if (flag == false)samples.erase(i++);
 92 |         else i++;
 93 |     }
 94 | }
 95 | 
 96 | Eigen::VectorXf
 97 |     NearNeighborDisMetric::_nncosine_distance(
 98 |         const FEATURESS & x, const FEATURESS & y)
 99 | {
100 |     MatrixXf distances = _cosine_distance(x, y);
101 |     VectorXf res = distances.colwise().minCoeff().transpose();
102 |     return res;
103 | }
104 | 
105 | Eigen::VectorXf
106 |     NearNeighborDisMetric::_nneuclidean_distance(
107 |         const FEATURESS & x, const FEATURESS & y)
108 | {
109 |     MatrixXf distances = _pdist(x, y);
110 |     VectorXf res = distances.colwise().maxCoeff().transpose();
111 |     res = res.array().max(VectorXf::Zero(res.rows()).array());
112 |     return res;
113 | }
114 | 
115 | Eigen::MatrixXf
116 |     NearNeighborDisMetric::_pdist(const FEATURESS & x, const FEATURESS & y)
117 | {
118 |     int len1 = x.rows(), len2 = y.rows();
119 |     if (len1 == 0 || len2 == 0) {
120 |         return Eigen::MatrixXf::Zero(len1, len2);
121 |     }
122 |     MatrixXf res = -2.0 * x * y.transpose();
123 |     res = res.colwise() + x.rowwise().squaredNorm();
124 |     res = res.rowwise() + y.rowwise().squaredNorm().transpose();
125 |     res = res.array().max(MatrixXf::Zero(res.rows(), res.cols()).array());
126 |     return res;
127 | }
128 | 
129 | Eigen::MatrixXf
130 |     NearNeighborDisMetric::_cosine_distance(
131 |         const FEATURESS & a, const FEATURESS & b, bool data_is_normalized)
132 | {
133 |     FEATURESS aa = a;
134 |     FEATURESS bb = b;
135 |     if (!data_is_normalized) {
136 |         //undo:
137 |         for (int i = 0; i < a.rows(); ++i) {
138 |             aa.row(i) =  a.row(i) / sqrt(a.row(i).squaredNorm());
139 |         }
140 |         for (int i = 0; i < b.rows(); ++i) {
141 |             bb.row(i) =  b.row(i) / sqrt(b.row(i).squaredNorm());
142 |         }        
143 |     }
144 |     MatrixXf res = 1. - (aa * bb.transpose()).array();
145 |     return res;
146 | }
147 | 


--------------------------------------------------------------------------------
/include/matrix.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *   Copyright (c) 2007 John Weaver
  3 |  *
  4 |  *   This program is free software; you can redistribute it and/or modify
  5 |  *   it under the terms of the GNU General Public License as published by
  6 |  *   the Free Software Foundation; either version 2 of the License, or
  7 |  *   (at your option) any later version.
  8 |  *
  9 |  *   This program is distributed in the hope that it will be useful,
 10 |  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  *   GNU General Public License for more details.
 13 |  *
 14 |  *   You should have received a copy of the GNU General Public License
 15 |  *   along with this program; if not, write to the Free Software
 16 |  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 17 |  */
 18 | 
 19 | #ifndef _MATRIX_H_
 20 | #define _MATRIX_H_
 21 | 
 22 | #include <initializer_list>
 23 | #include <cstdlib>
 24 | #include <ostream>
 25 | #include <cassert>
 26 | #include <cstdlib>
 27 | #include <algorithm>
 28 | 
 29 | #define XYZMIN(x, y) (x)<(y)?(x):(y)
 30 | #define XYZMAX(x, y) (x)>(y)?(x):(y)
 31 | 
 32 | template <class T>
 33 | class Matrix {
 34 | public:
 35 | 	Matrix(){
 36 | 		m_rows = 0;
 37 | 		m_columns = 0;
 38 | 		m_matrix = nullptr;
 39 | 	}
 40 | 	Matrix(const size_t rows, const size_t columns)  {
 41 | 		m_matrix = nullptr;
 42 | 		resize(rows, columns);
 43 | 	}
 44 | 	Matrix(const std::initializer_list<std::initializer_list<T>> init) {
 45 | 		m_matrix = nullptr;
 46 | 		m_rows = init.size();
 47 | 		if ( m_rows == 0 ) {
 48 | 			m_columns = 0;
 49 | 		} else {
 50 | 			m_columns = init.begin()->size();
 51 | 			if ( m_columns > 0 ) {
 52 | 				resize(m_rows, m_columns);
 53 | 			}
 54 | 		}
 55 | 
 56 | 		size_t i = 0, j;
 57 | 		for ( auto row = init.begin() ; row != init.end() ; ++row, ++i ) {
 58 | 			assert ( row->size() == m_columns && "All rows must have the same number of columns." );
 59 | 			j = 0;
 60 | 			for ( auto value = row->begin() ; value != row->end() ; ++value, ++j ) {
 61 | 				m_matrix[i][j] = *value;
 62 | 			}
 63 | 		}
 64 | 	}
 65 | 	Matrix(const Matrix<T> &other)  {
 66 | 		if ( other.m_matrix != nullptr ) {
 67 | 			// copy arrays
 68 | 			m_matrix = nullptr;
 69 | 			resize(other.m_rows, other.m_columns);
 70 | 			for ( size_t i = 0 ; i < m_rows ; i++ ) {
 71 | 				for ( size_t j = 0 ; j < m_columns ; j++ ) {
 72 | 					m_matrix[i][j] = other.m_matrix[i][j];
 73 | 				}
 74 | 			}
 75 | 		} else {
 76 | 			m_matrix = nullptr;
 77 | 			m_rows = 0;
 78 | 			m_columns = 0;
 79 | 		}
 80 | 	}
 81 | 	Matrix<T> & operator= (const Matrix<T> &other){
 82 | 		if ( other.m_matrix != nullptr ) {
 83 | 			// copy arrays
 84 | 			resize(other.m_rows, other.m_columns);
 85 | 			for ( size_t i = 0 ; i < m_rows ; i++ ) {
 86 | 				for ( size_t j = 0 ; j < m_columns ; j++ ) {
 87 | 					m_matrix[i][j] = other.m_matrix[i][j];
 88 | 				}
 89 | 			}
 90 | 		} else {
 91 | 			// free arrays
 92 | 			for ( size_t i = 0 ; i < m_columns ; i++ ) {
 93 | 				delete [] m_matrix[i];
 94 | 			}
 95 | 
 96 | 			delete [] m_matrix;
 97 | 
 98 | 			m_matrix = nullptr;
 99 | 			m_rows = 0;
100 | 			m_columns = 0;
101 | 		}
102 | 
103 | 		return *this;
104 | 	}
105 | 	~Matrix(){
106 | 		if ( m_matrix != nullptr ) {
107 | 			// free arrays
108 | 			for ( size_t i = 0 ; i < m_rows ; i++ ) {
109 | 				delete [] m_matrix[i];
110 | 			}
111 | 
112 | 			delete [] m_matrix;
113 | 		}
114 | 		m_matrix = nullptr;
115 | 	}
116 | 	// all operations modify the matrix in-place.
117 | 	void resize(const size_t rows, const size_t columns, const T default_value = 0) {
118 | 		assert ( rows > 0 && columns > 0 && "Columns and rows must exist." );
119 | 
120 | 		if ( m_matrix == nullptr ) {
121 | 			// alloc arrays
122 | 			m_matrix = new T*[rows]; // rows
123 | 			for ( size_t i = 0 ; i < rows ; i++ ) {
124 | 				m_matrix[i] = new T[columns]; // columns
125 | 			}
126 | 
127 | 			m_rows = rows;
128 | 			m_columns = columns;
129 | 			clear();
130 | 		} else {
131 | 			// save array pointer
132 | 			T **new_matrix;
133 | 			// alloc new arrays
134 | 			new_matrix = new T*[rows]; // rows
135 | 			for ( size_t i = 0 ; i < rows ; i++ ) {
136 | 				new_matrix[i] = new T[columns]; // columns
137 | 				for ( size_t j = 0 ; j < columns ; j++ ) {
138 | 					new_matrix[i][j] = default_value;
139 | 				}
140 | 			}
141 | 
142 | 			// copy data from saved pointer to new arrays
143 | 			size_t minrows = XYZMIN(rows, m_rows);
144 | 			size_t mincols = XYZMIN(columns, m_columns);
145 | 			for ( size_t x = 0 ; x < minrows ; x++ ) {
146 | 				for ( size_t y = 0 ; y < mincols ; y++ ) {
147 | 					new_matrix[x][y] = m_matrix[x][y];
148 | 				}
149 | 			}
150 | 
151 | 			// delete old arrays
152 | 			if ( m_matrix != nullptr ) {
153 | 				for ( size_t i = 0 ; i < m_rows ; i++ ) {
154 | 					delete [] m_matrix[i];
155 | 				}
156 | 
157 | 				delete [] m_matrix;
158 | 			}
159 | 
160 | 			m_matrix = new_matrix;
161 | 		}
162 | 
163 | 		m_rows = rows;
164 | 		m_columns = columns;
165 | 	}
166 | 	void clear() {
167 | 		assert( m_matrix != nullptr );
168 | 
169 | 		for ( size_t i = 0 ; i < m_rows ; i++ ) {
170 | 			for ( size_t j = 0 ; j < m_columns ; j++ ) {
171 | 				m_matrix[i][j] = 0;
172 | 			}
173 | 		}
174 | 	}
175 | 	T& operator () (const size_t x, const size_t y) {
176 | 		assert ( x < m_rows );
177 | 		assert ( y < m_columns );
178 | 		assert ( m_matrix != nullptr );
179 | 		return m_matrix[x][y];
180 | 	}
181 | 
182 | 	const T& operator () (const size_t x, const size_t y) const {
183 | 		assert ( x < m_rows );
184 | 		assert ( y < m_columns );
185 | 		assert ( m_matrix != nullptr );
186 | 		return m_matrix[x][y];
187 | 	}
188 | 	const T mmin() const {
189 | 		assert( m_matrix != nullptr );
190 | 		assert ( m_rows > 0 );
191 | 		assert ( m_columns > 0 );
192 | 		T min = m_matrix[0][0];
193 | 
194 | 		for ( size_t i = 0 ; i < m_rows ; i++ ) {
195 | 			for ( size_t j = 0 ; j < m_columns ; j++ ) {
196 | 				min = std::min<T>(min, m_matrix[i][j]);
197 | 			}
198 | 		}
199 | 
200 | 		return min;
201 | 	}
202 | 
203 | 	const T mmax() const {
204 | 		assert( m_matrix != nullptr );
205 | 		assert ( m_rows > 0 );
206 | 		assert ( m_columns > 0 );
207 | 		T max = m_matrix[0][0];
208 | 
209 | 		for ( size_t i = 0 ; i < m_rows ; i++ ) {
210 | 			for ( size_t j = 0 ; j < m_columns ; j++ ) {
211 | 				max = std::max<T>(max, m_matrix[i][j]);
212 | 			}
213 | 		}
214 | 
215 | 		return max;
216 | 	}
217 | 	inline size_t minsize() { return ((m_rows < m_columns) ? m_rows : m_columns); }
218 | 	inline size_t columns() const { return m_columns;}
219 | 	inline size_t rows() const { return m_rows;}
220 | 
221 | 	friend std::ostream& operator<<(std::ostream& os, const Matrix &matrix)
222 | 	{
223 | 		os << "Matrix:" << std::endl;
224 | 		for (size_t row = 0 ; row < matrix.rows() ; row++ )
225 | 		{
226 | 			for (size_t col = 0 ; col < matrix.columns() ; col++ )
227 | 			{
228 | 				os.width(8);
229 | 				os << matrix(row, col) << ",";
230 | 			}
231 | 			os << std::endl;
232 | 		}
233 | 		return os;
234 | 	}
235 | 
236 | private:
237 | 	T **m_matrix;
238 | 	size_t m_rows;
239 | 	size_t m_columns;
240 | };
241 | 
242 | //#ifndef USE_EXPORT_KEYWORD
243 | //#include "matrix.cpp"
244 | ////#define export /*export*/
245 | //#endif
246 | 
247 | #endif /* !defined(_MATRIX_H_) */
248 | 
249 | 


--------------------------------------------------------------------------------
/src/featuretensor.cpp:
--------------------------------------------------------------------------------
  1 | #include "featuretensor.h"
  2 | #include <fstream>
  3 | 
  4 | using namespace nvinfer1;
  5 | 
  6 | #define INPUTSTREAM_SIZE (maxBatchSize*3*imgShape.area())
  7 | #define OUTPUTSTREAM_SIZE (maxBatchSize*featureDim)
  8 | 
  9 | FeatureTensor::FeatureTensor(const int maxBatchSize, const cv::Size imgShape, const int featureDim, int gpuID, ILogger* gLogger) 
 10 |         : maxBatchSize(maxBatchSize), imgShape(imgShape), featureDim(featureDim), 
 11 |         inputStreamSize(INPUTSTREAM_SIZE), outputStreamSize(OUTPUTSTREAM_SIZE),
 12 |         inputBuffer(new float[inputStreamSize]), outputBuffer(new float[outputStreamSize]),
 13 |         inputName("input"), outputName("output") {
 14 |     cudaSetDevice(gpuID);
 15 |     this->gLogger = gLogger;
 16 |     runtime = nullptr;
 17 |     engine = nullptr;
 18 |     context = nullptr; 
 19 | 
 20 |     means[0] = 0.485, means[1] = 0.456, means[2] = 0.406;
 21 |     std[0] = 0.229, std[1] = 0.224, std[2] = 0.225;
 22 | 
 23 |     initFlag = false;
 24 | }
 25 | 
 26 | FeatureTensor::~FeatureTensor() {
 27 |     delete [] inputBuffer; 
 28 |     delete [] outputBuffer;
 29 |     if (initFlag) {
 30 |         // cudaStreamSynchronize(cudaStream);
 31 |         cudaStreamDestroy(cudaStream);
 32 |         cudaFree(buffers[inputIndex]);
 33 |         cudaFree(buffers[outputIndex]);
 34 |     }
 35 | }
 36 | 
 37 | bool FeatureTensor::getRectsFeature(const cv::Mat& img, DETECTIONS& det) {
 38 |     std::vector<cv::Mat> mats;
 39 |     for (auto& dbox : det) {
 40 |         cv::Rect rect = cv::Rect(int(dbox.tlwh(0)), int(dbox.tlwh(1)),
 41 |                                  int(dbox.tlwh(2)), int(dbox.tlwh(3)));
 42 |         rect.x -= (rect.height * 0.5 - rect.width) * 0.5;
 43 |         rect.width = rect.height * 0.5;
 44 |         rect.x = (rect.x >= 0 ? rect.x : 0);
 45 |         rect.y = (rect.y >= 0 ? rect.y : 0);
 46 |         rect.width = (rect.x + rect.width <= img.cols ? rect.width : (img.cols - rect.x));
 47 |         rect.height = (rect.y + rect.height <= img.rows ? rect.height : (img.rows - rect.y));
 48 |         cv::Mat tempMat = img(rect).clone();
 49 |         cv::resize(tempMat, tempMat, imgShape);
 50 |         mats.push_back(tempMat);
 51 |     }
 52 |     doInference(mats);
 53 |     // decode output to det
 54 |     stream2det(outputBuffer, det);
 55 |     return true;
 56 | }
 57 | 
 58 | bool FeatureTensor::getRectsFeature(DETECTIONS& det) {
 59 |     return true;
 60 | }
 61 | 
 62 | void FeatureTensor::loadEngine(std::string enginePath) {
 63 |     // Deserialize model
 64 |     runtime = createInferRuntime(*gLogger);
 65 |     assert(runtime != nullptr);
 66 |     std::ifstream engineStream(enginePath, std::ios::binary);
 67 |     std::string engineCache("");
 68 |     while (engineStream.peek() != EOF) {
 69 |         std::stringstream buffer;
 70 |         buffer << engineStream.rdbuf();
 71 |         engineCache.append(buffer.str());
 72 |     }
 73 |     engineStream.close();
 74 |     engine = runtime->deserializeCudaEngine(engineCache.data(), engineCache.size(), nullptr);
 75 |     assert(engine != nullptr);
 76 |     context = engine->createExecutionContext();
 77 |     assert(context != nullptr);
 78 |     initResource();
 79 | } 
 80 | 
 81 | void FeatureTensor::loadOnnx(std::string onnxPath) {
 82 |     auto builder = createInferBuilder(*gLogger);
 83 |     assert(builder != nullptr);
 84 |     const auto explicitBatch = 1U << static_cast<uint32_t>(NetworkDefinitionCreationFlag::kEXPLICIT_BATCH);
 85 |     auto network = builder->createNetworkV2(explicitBatch);
 86 |     assert(network != nullptr);
 87 |     auto config = builder->createBuilderConfig();
 88 |     assert(config != nullptr);
 89 | 
 90 |     auto profile = builder->createOptimizationProfile();
 91 |     Dims dims = Dims4{1, 3, imgShape.height, imgShape.width};
 92 |     profile->setDimensions(inputName.c_str(),
 93 |                 OptProfileSelector::kMIN, Dims4{1, dims.d[1], dims.d[2], dims.d[3]});
 94 |     profile->setDimensions(inputName.c_str(),
 95 |                 OptProfileSelector::kOPT, Dims4{maxBatchSize, dims.d[1], dims.d[2], dims.d[3]});
 96 |     profile->setDimensions(inputName.c_str(),
 97 |                 OptProfileSelector::kMAX, Dims4{maxBatchSize, dims.d[1], dims.d[2], dims.d[3]});
 98 |     config->addOptimizationProfile(profile);
 99 | 
100 |     nvonnxparser::IParser* parser = nvonnxparser::createParser(*network, *gLogger);
101 |     assert(parser != nullptr);
102 |     auto parsed = parser->parseFromFile(onnxPath.c_str(), static_cast<int>(ILogger::Severity::kWARNING));
103 |     assert(parsed);
104 |     config->setMaxWorkspaceSize(1 << 20);
105 |     engine = builder->buildEngineWithConfig(*network, *config);
106 |     assert(engine != nullptr);
107 |     context = engine->createExecutionContext();
108 |     assert(context != nullptr);
109 |     initResource();
110 | }
111 | 
112 | int FeatureTensor::getResult(float*& buffer) {
113 |     if (buffer != nullptr)
114 |         delete buffer;
115 |     int curStreamSize = curBatchSize*featureDim;
116 |     buffer = new float[curStreamSize];
117 |     for (int i = 0; i < curStreamSize; ++i) {
118 |         buffer[i] = outputBuffer[i];
119 |     }
120 |     return curStreamSize;
121 | }
122 | 
123 | void FeatureTensor::doInference(vector<cv::Mat>& imgMats) {
124 |     mat2stream(imgMats, inputBuffer);
125 |     doInference(inputBuffer, outputBuffer);
126 | }
127 | 
128 | void FeatureTensor::initResource() {
129 |     inputIndex = engine->getBindingIndex(inputName.c_str());
130 |     outputIndex = engine->getBindingIndex(outputName.c_str());
131 |     // Create CUDA stream
132 |     cudaStreamCreate(&cudaStream);
133 |     buffers[inputIndex] = inputBuffer;
134 |     buffers[outputIndex] = outputBuffer;
135 |     
136 |     // Malloc CUDA memory
137 |     cudaMalloc(&buffers[inputIndex], inputStreamSize * sizeof(float));
138 |     cudaMalloc(&buffers[outputIndex], outputStreamSize * sizeof(float));
139 |     
140 |     initFlag = true;
141 | }
142 | 
143 | void FeatureTensor::doInference(float* inputBuffer, float* outputBuffer) {   
144 |     cudaMemcpyAsync(buffers[inputIndex], inputBuffer, inputStreamSize * sizeof(float), cudaMemcpyHostToDevice, cudaStream);
145 |     Dims4 inputDims{curBatchSize, 3, imgShape.height, imgShape.width};
146 |     context->setBindingDimensions(0, inputDims);
147 |     
148 |     context->enqueueV2(buffers, cudaStream, nullptr);
149 |     cudaMemcpyAsync(outputBuffer, buffers[outputIndex], outputStreamSize * sizeof(float), cudaMemcpyDeviceToHost, cudaStream);
150 |     // cudaStreamSynchronize(cudaStream);
151 | }
152 | 
153 | void FeatureTensor::mat2stream(vector<cv::Mat>& imgMats, float* stream) {
154 |     int imgArea = imgShape.area();
155 |     curBatchSize = imgMats.size();
156 |     if (curBatchSize > maxBatchSize) {
157 |         std::cout << "[WARNING]::Batch size overflow, input will be truncated!" << std::endl;
158 |         curBatchSize = maxBatchSize;
159 |     }
160 |     for (int batch = 0; batch < curBatchSize; ++batch) {
161 |         cv::Mat tempMat = imgMats[batch];
162 |         int i = 0; 
163 |         for (int row = 0; row < imgShape.height; ++row) {
164 |             uchar* uc_pixel = tempMat.data + row * tempMat.step;
165 |             for (int col = 0; col < imgShape.width; ++col) {
166 |                 stream[batch * 3 * imgArea + i] = ((float)uc_pixel[0] / 255.0 - means[0]) / std[0];
167 |                 stream[batch * 3 * imgArea + i + imgArea] = ((float)uc_pixel[1] / 255.0 - means[1]) / std[1];
168 |                 stream[batch * 3 * imgArea + i + 2 * imgArea] = ((float)uc_pixel[2] / 255.0 - means[2]) / std[2];
169 |                 uc_pixel += 3;
170 |                 ++i;
171 |             }
172 |         }
173 |     }
174 | }
175 | 
176 | void FeatureTensor::stream2det(float* stream, DETECTIONS& det) {
177 |     int i = 0;
178 |     for (DETECTION_ROW& dbox : det) {
179 |         for (int j = 0; j < featureDim; ++j)
180 |             dbox.feature[j] = stream[i * featureDim + j];
181 |             // dbox.feature[j] = (float)1.0;
182 |         ++i;
183 |     }
184 | }
185 | 


--------------------------------------------------------------------------------
/src/linear_assignment.cpp:
--------------------------------------------------------------------------------
  1 | #include "linear_assignment.h"
  2 | #include "hungarianoper.h"
  3 | #include <map>
  4 | 
  5 | linear_assignment *linear_assignment::instance = NULL;
  6 | linear_assignment::linear_assignment()
  7 | {
  8 | }
  9 | 
 10 | linear_assignment *linear_assignment::getInstance()
 11 | {
 12 |     if(instance == NULL) instance = new linear_assignment();
 13 |     return instance;
 14 | }
 15 | 
 16 | TRACHER_MATCHD
 17 | linear_assignment::matching_cascade(
 18 |         tracker *distance_metric,
 19 |         tracker::GATED_METRIC_FUNC distance_metric_func,
 20 |         float max_distance,
 21 |         int cascade_depth,
 22 |         std::vector<Track> &tracks,
 23 |         const DETECTIONS &detections,
 24 |         std::vector<int>& track_indices,
 25 |         std::vector<int> detection_indices)
 26 | {
 27 |     TRACHER_MATCHD res;
 28 |     // std::cout << "distance_metric" << distance_metric << std::endl;
 29 |     // std::cout << "max_distance" << max_distance << std::endl;
 30 |     // std::cout << "cascade_depth" << cascade_depth << std::endl;
 31 |     // std::cout << "tracks [" << std::endl;
 32 |     // for (auto i : tracks)
 33 |     //     std::cout << i.hits << ", ";
 34 |     // std::cout << "]" << endl;
 35 |     // std::cout << "detections [" << std::endl;
 36 |     // for (auto i : detections)
 37 |     //     std::cout << i.confidence << ", ";
 38 |     // std::cout << "]" << endl;
 39 |     // std::cout << "track_indices [" << std::endl;
 40 |     // for (auto i : track_indices)
 41 |     //     std::cout << i << ", ";
 42 |     // std::cout << "]" << endl;
 43 |     // std::cout << "detection_indices [" << std::endl;
 44 |     // for (auto i : detection_indices)
 45 |     //     std::cout << i << ", ";
 46 |     // std::cout << "]" << endl;
 47 |     // !!!python diff: track_indices will never be None.
 48 |     //    if(track_indices.empty() == true) {
 49 |     //        for(size_t i = 0; i < tracks.size(); i++) {
 50 |     //            track_indices.push_back(i);
 51 |     //        }
 52 |     //    }
 53 | 
 54 |     //!!!python diff: detection_indices will always be None.
 55 |     for(size_t i = 0; i < detections.size(); i++) {
 56 |         detection_indices.push_back(int(i));
 57 |     }
 58 | 
 59 |     std::vector<int> unmatched_detections;
 60 |     unmatched_detections.assign(detection_indices.begin(), detection_indices.end());
 61 |     res.matches.clear();
 62 |     std::vector<int> track_indices_l;
 63 | 
 64 |     std::map<int, int> matches_trackid;
 65 |     for(int level = 0; level < cascade_depth; level++) {
 66 |         if(unmatched_detections.size() == 0) break; //No detections left;
 67 | 
 68 |         track_indices_l.clear();
 69 |         for(int k:track_indices) {
 70 |             if(tracks[k].time_since_update == 1+level)
 71 |                 track_indices_l.push_back(k);
 72 |         }
 73 |         if(track_indices_l.size() == 0) continue; //Nothing to match at this level.
 74 | 
 75 |         TRACHER_MATCHD tmp = min_cost_matching(
 76 |                     distance_metric, distance_metric_func,
 77 |                     max_distance, tracks, detections, track_indices_l,
 78 |                     unmatched_detections);
 79 |         unmatched_detections.assign(tmp.unmatched_detections.begin(), tmp.unmatched_detections.end());
 80 |         for(size_t i = 0; i < tmp.matches.size(); i++) {
 81 |             MATCH_DATA pa = tmp.matches[i];
 82 |             res.matches.push_back(pa);
 83 |             matches_trackid.insert(pa);
 84 |         }
 85 |     }
 86 |     res.unmatched_detections.assign(unmatched_detections.begin(), unmatched_detections.end());
 87 |     for(size_t i = 0; i < track_indices.size(); i++) {
 88 |         int tid = track_indices[i];
 89 |         if(matches_trackid.find(tid) == matches_trackid.end())
 90 |             res.unmatched_tracks.push_back(tid);
 91 |     }
 92 |     return res;
 93 | }
 94 | 
 95 | TRACHER_MATCHD
 96 | linear_assignment::min_cost_matching(tracker *distance_metric,
 97 |         tracker::GATED_METRIC_FUNC distance_metric_func,
 98 |         float max_distance,
 99 |         std::vector<Track> &tracks,
100 |         const DETECTIONS &detections,
101 |         std::vector<int> &track_indices,
102 |         std::vector<int> &detection_indices)
103 | {
104 |     TRACHER_MATCHD res;
105 |     //!!!python diff: track_indices && detection_indices will never be None.
106 |     //    if(track_indices.empty() == true) {
107 |     //        for(size_t i = 0; i < tracks.size(); i++) {
108 |     //            track_indices.push_back(i);
109 |     //        }
110 |     //    }
111 |     //    if(detection_indices.empty() == true) {
112 |     //        for(size_t i = 0; i < detections.size(); i++) {
113 |     //            detection_indices.push_back(int(i));
114 |     //        }
115 |     //    }
116 |     if((detection_indices.size() == 0) || (track_indices.size() == 0)) {
117 |         res.matches.clear();
118 |         res.unmatched_tracks.assign(track_indices.begin(), track_indices.end());
119 |         res.unmatched_detections.assign(detection_indices.begin(), detection_indices.end());
120 |         return res;
121 |     }
122 |     DYNAMICM cost_matrix = (distance_metric->*(distance_metric_func))(
123 |                 tracks, detections, track_indices, detection_indices);
124 |     for(int i = 0; i < cost_matrix.rows(); i++) {
125 |         for(int j = 0; j < cost_matrix.cols(); j++) {
126 |             float tmp = cost_matrix(i,j);
127 |             if(tmp > max_distance) cost_matrix(i,j) = max_distance + 1e-5;
128 |         }
129 |     }
130 |     Eigen::Matrix<float, -1, 2, Eigen::RowMajor> indices = HungarianOper::Solve(cost_matrix);
131 |     res.matches.clear();
132 |     res.unmatched_tracks.clear();
133 |     res.unmatched_detections.clear();
134 |     for(size_t col = 0; col < detection_indices.size(); col++) {
135 |         bool flag = false;
136 |         for(int i = 0; i < indices.rows(); i++)
137 |             if(indices(i, 1) == col) { flag = true; break;}
138 |         if(flag == false)res.unmatched_detections.push_back(detection_indices[col]);
139 |     }
140 |     for(size_t row = 0; row < track_indices.size(); row++) {
141 |         bool flag = false;
142 |         for(int i = 0; i < indices.rows(); i++)
143 |             if(indices(i, 0) == row) { flag = true; break; }
144 |         if(flag == false) res.unmatched_tracks.push_back(track_indices[row]);
145 |     }
146 |     for(int i = 0; i < indices.rows(); i++) {
147 |         int row = indices(i, 0);
148 |         int col = indices(i, 1);
149 | 
150 |         int track_idx = track_indices[row];
151 |         int detection_idx = detection_indices[col];
152 |         if(cost_matrix(row, col) > max_distance) {
153 |             res.unmatched_tracks.push_back(track_idx);
154 |             res.unmatched_detections.push_back(detection_idx);
155 |         } else res.matches.push_back(std::make_pair(track_idx, detection_idx));
156 |     }
157 |     return res;
158 | }
159 | 
160 | DYNAMICM
161 | linear_assignment::gate_cost_matrix(
162 |         KalmanFilter *kf,
163 |         DYNAMICM &cost_matrix,
164 |         std::vector<Track> &tracks,
165 |         const DETECTIONS &detections,
166 |         const std::vector<int> &track_indices,
167 |         const std::vector<int> &detection_indices,
168 |         float gated_cost, bool only_position)
169 | {
170 |     // std::cout << "input cost matric" << cost_matrix << std::endl;
171 |     int gating_dim = (only_position == true?2:4);
172 |     double gating_threshold = KalmanFilter::chi2inv95[gating_dim];
173 |     std::vector<DETECTBOX> measurements;
174 |     for(int i:detection_indices) {
175 |         DETECTION_ROW t = detections[i];
176 |         measurements.push_back(t.to_xyah());
177 |     }
178 |     for(size_t i  = 0; i < track_indices.size(); i++) {
179 |         Track& track = tracks[track_indices[i]];
180 |         Eigen::Matrix<float, 1, -1> gating_distance = kf->gating_distance(
181 |                     track.mean, track.covariance, measurements, only_position);
182 |         for (int j = 0; j < gating_distance.cols(); j++) {
183 |             if (gating_distance(0, j) > gating_threshold)  cost_matrix(i, j) = gated_cost;
184 |         }
185 |     }
186 |     // std::cout << "out cost matrix" << cost_matrix << std::endl;
187 |     return cost_matrix;
188 | }
189 | 
190 | 


--------------------------------------------------------------------------------
/src/tracker.cpp:
--------------------------------------------------------------------------------
  1 | #include "tracker.h"
  2 | #include "nn_matching.h"
  3 | #include "linear_assignment.h"
  4 | using namespace std;
  5 | 
  6 | #define MY_inner_DEBUG
  7 | #ifdef MY_inner_DEBUG
  8 | #include <string>
  9 | #include <iostream>
 10 | #endif
 11 | using namespace std;
 12 | tracker::tracker(               /*NearNeighborDisMetric *metric, */
 13 |     float max_cosine_distance, int nn_budget,
 14 |     float max_iou_distance, int max_age, int n_init)
 15 | {
 16 |     this->metric = new NearNeighborDisMetric(
 17 |         NearNeighborDisMetric::METRIC_TYPE::cosine, 
 18 |         max_cosine_distance, nn_budget);
 19 |     this->max_iou_distance = max_iou_distance;
 20 |     this->max_age = max_age;
 21 |     this->n_init = n_init;
 22 | 
 23 |     this->kf = new KalmanFilter();
 24 |     this->tracks.clear();
 25 |     this->_next_idx = 1;
 26 | }
 27 | 
 28 | void tracker::predict()
 29 | {
 30 |   for (Track & track:tracks) {
 31 |         track.predit(kf);
 32 |     }
 33 | }
 34 | 
 35 | void tracker::update(const DETECTIONS & detections)
 36 | {
 37 |     TRACHER_MATCHD res;
 38 |     _match(detections, res);
 39 | 
 40 |     vector < MATCH_DATA > &matches = res.matches;
 41 |     for (MATCH_DATA & data:matches) {
 42 |         int track_idx = data.first;
 43 |         int detection_idx = data.second;
 44 |         tracks[track_idx].update(this->kf, detections[detection_idx]);
 45 |     }
 46 |     vector < int >&unmatched_tracks = res.unmatched_tracks;
 47 |     for (int &track_idx:unmatched_tracks) {
 48 |         this->tracks[track_idx].mark_missed();
 49 |     }
 50 |     vector < int >&unmatched_detections = res.unmatched_detections;
 51 |     for (int &detection_idx:unmatched_detections) {
 52 |         this->_initiate_track(detections[detection_idx]);
 53 |     }
 54 |     vector < Track >::iterator it;
 55 |     for (it = tracks.begin(); it != tracks.end();) {
 56 |         if ((*it).is_deleted()) it = tracks.erase(it);
 57 |         else ++it;
 58 |     }
 59 |     vector < int >active_targets;
 60 |     vector < TRACKER_DATA > tid_features;
 61 |   for (Track & track:tracks) {
 62 |         if (track.is_confirmed() == false) continue;
 63 |         active_targets.push_back(track.track_id);
 64 |         tid_features.push_back(std::make_pair(track. track_id, track.features));
 65 |         FEATURESS t = FEATURESS(0, 256);
 66 |         track.features = t;
 67 |     }
 68 |     this->metric->partial_fit(tid_features, active_targets);
 69 | }
 70 | 
 71 | void tracker::update(const DETECTIONSV2 & detectionsv2)
 72 | {
 73 |     const vector<CLSCONF>& clsConf = detectionsv2.first;
 74 |     const DETECTIONS& detections = detectionsv2.second;
 75 |     TRACHER_MATCHD res;
 76 |     _match(detections, res);
 77 | 
 78 |     vector < MATCH_DATA > &matches = res.matches;
 79 |   for (MATCH_DATA & data:matches) {
 80 |         int track_idx = data.first;
 81 |         int detection_idx = data.second;
 82 |         tracks[track_idx].update(this->kf, detections[detection_idx], clsConf[detection_idx]);
 83 |     }
 84 |     vector < int >&unmatched_tracks = res.unmatched_tracks;
 85 |   for (int &track_idx:unmatched_tracks) {
 86 |         this->tracks[track_idx].mark_missed();
 87 |     }
 88 |     vector < int >&unmatched_detections = res.unmatched_detections;
 89 |   for (int &detection_idx:unmatched_detections) {
 90 |         this->_initiate_track(detections[detection_idx], clsConf[detection_idx]);
 91 |     }
 92 |     vector < Track >::iterator it;
 93 |     for (it = tracks.begin(); it != tracks.end();) {
 94 |         if ((*it).is_deleted()) it = tracks.erase(it);
 95 |         else ++it;
 96 |     }
 97 |     vector < int >active_targets;
 98 |     vector < TRACKER_DATA > tid_features;
 99 |   for (Track & track:tracks) {
100 |         if (track.is_confirmed() == false) continue;
101 |         active_targets.push_back(track.track_id);
102 |         tid_features.push_back(std::make_pair(track. track_id, track.features));
103 |         FEATURESS t = FEATURESS(0, 256);
104 |         track.features = t;
105 |     }
106 |     this->metric->partial_fit(tid_features, active_targets);
107 | }
108 | 
109 | void tracker::_match(const DETECTIONS & detections, TRACHER_MATCHD & res)
110 | {
111 |     vector < int >confirmed_tracks;
112 |     vector < int >unconfirmed_tracks;
113 |     int idx = 0;
114 |   for (Track & t:tracks) {
115 |         if (t.is_confirmed()) confirmed_tracks.push_back(idx);
116 |         else unconfirmed_tracks.push_back(idx);
117 |         idx++;
118 |     }
119 | 
120 |     TRACHER_MATCHD matcha = linear_assignment::getInstance()-> matching_cascade(
121 |         this, &tracker::gated_matric,
122 |         this->metric->mating_threshold,
123 |         this->max_age,
124 |         this->tracks,
125 |         detections,
126 |         confirmed_tracks);
127 |     vector < int >iou_track_candidates;
128 |     iou_track_candidates.assign(unconfirmed_tracks.begin(), unconfirmed_tracks.end());
129 |     vector < int >::iterator it;
130 |     for (it = matcha.unmatched_tracks.begin(); it != matcha.unmatched_tracks.end();) {
131 |         int idx = *it;
132 |         if (tracks[idx].time_since_update == 1) {       //push into unconfirmed
133 |             iou_track_candidates.push_back(idx);
134 |             it = matcha.unmatched_tracks.erase(it);
135 |             continue;
136 |         }
137 |         ++it;
138 |     }
139 |     TRACHER_MATCHD matchb = linear_assignment::getInstance()->min_cost_matching(
140 |         this, &tracker::iou_cost,
141 |         this->max_iou_distance,
142 |         this->tracks,
143 |         detections,
144 |         iou_track_candidates,
145 |         matcha.unmatched_detections);
146 |     //get result:
147 |     res.matches.assign(matcha.matches.begin(), matcha.matches.end());
148 |     res.matches.insert(res.matches.end(), matchb.matches.begin(), matchb.matches.end());
149 |     //unmatched_tracks;
150 |     res.unmatched_tracks.assign(
151 |         matcha.unmatched_tracks.begin(), 
152 |         matcha.unmatched_tracks.end());
153 |     res.unmatched_tracks.insert(
154 |         res.unmatched_tracks.end(),
155 |         matchb.unmatched_tracks.begin(),
156 |         matchb.unmatched_tracks.end());
157 |     res.unmatched_detections.assign(
158 |         matchb.unmatched_detections.begin(),
159 |         matchb.unmatched_detections.end());
160 | }
161 | 
162 | void tracker::_initiate_track(const DETECTION_ROW & detection)
163 | {
164 |     KAL_DATA data = kf->initiate(detection.to_xyah());
165 |     KAL_MEAN mean = data.first;
166 |     KAL_COVA covariance = data.second;
167 | 
168 |     this->tracks.push_back(Track(mean, covariance, this->_next_idx, this->n_init, 
169 |                             this->max_age, detection.feature));
170 |     _next_idx += 1;
171 | }
172 | void tracker::_initiate_track(const DETECTION_ROW& detection, CLSCONF clsConf)
173 | {
174 |     KAL_DATA data = kf->initiate(detection.to_xyah());
175 |     KAL_MEAN mean = data.first;
176 |     KAL_COVA covariance = data.second;
177 | 
178 |     this->tracks.push_back(Track(mean, covariance, this->_next_idx, this->n_init, 
179 |                             this->max_age, detection.feature, clsConf.cls, clsConf.conf));
180 |     _next_idx += 1;
181 | }
182 | 
183 | DYNAMICM tracker::gated_matric(
184 |     std::vector < Track > &tracks, 
185 |     const DETECTIONS & dets,
186 |     const std::vector < int >&track_indices,
187 |     const std::vector < int >&detection_indices)
188 | {
189 |     FEATURESS features(detection_indices.size(), 256);
190 |     int pos = 0;
191 |   for (int i:detection_indices) {
192 |         features.row(pos++) = dets[i].feature;
193 |     }
194 |     vector < int >targets;
195 |   for (int i:track_indices) {
196 |         targets.push_back(tracks[i].track_id);
197 |     }
198 |     DYNAMICM cost_matrix = this->metric->distance(features, targets);
199 |     DYNAMICM res = linear_assignment::getInstance()->gate_cost_matrix(
200 |         this->kf, cost_matrix, tracks, dets, track_indices,
201 |         detection_indices);
202 |     return res;
203 | }
204 | 
205 | DYNAMICM
206 | tracker::iou_cost(
207 |     std::vector < Track > &tracks,
208 |     const DETECTIONS & dets,
209 |     const std::vector < int >&track_indices,
210 |     const std::vector < int >&detection_indices)
211 | {
212 |     //!!!python diff: track_indices && detection_indices will never be None.
213 |     //    if(track_indices.empty() == true) {
214 |     //        for(size_t i = 0; i < tracks.size(); i++) {
215 |     //            track_indices.push_back(i);
216 |     //        }
217 |     //    }
218 |     //    if(detection_indices.empty() == true) {
219 |     //        for(size_t i = 0; i < dets.size(); i++) {
220 |     //            detection_indices.push_back(i);
221 |     //        }
222 |     //    }
223 |     int rows = track_indices.size();
224 |     int cols = detection_indices.size();
225 |     DYNAMICM cost_matrix = Eigen::MatrixXf::Zero(rows, cols);
226 |     for (int i = 0; i < rows; i++) {
227 |         int track_idx = track_indices[i];
228 |         if (tracks[track_idx].time_since_update > 1) {
229 |             cost_matrix.row(i) = Eigen::RowVectorXf::Constant(cols, INFTY_COST);
230 |             continue;
231 |         }
232 |         DETECTBOX bbox = tracks[track_idx].to_tlwh();
233 |         int csize = detection_indices.size();
234 |         DETECTBOXSS candidates(csize, 4);
235 |         for (int k = 0; k < csize; k++) candidates.row(k) = dets[detection_indices[k]].tlwh;
236 |         Eigen::RowVectorXf rowV = (1. - iou(bbox, candidates).array()).matrix().transpose();
237 |         cost_matrix.row(i) = rowV;
238 |     }
239 |     return cost_matrix;
240 | }
241 | 
242 | Eigen::VectorXf
243 |     tracker::iou(DETECTBOX & bbox, DETECTBOXSS & candidates)
244 | {
245 |     float bbox_tl_1 = bbox[0];
246 |     float bbox_tl_2 = bbox[1];
247 |     float bbox_br_1 = bbox[0] + bbox[2];
248 |     float bbox_br_2 = bbox[1] + bbox[3];
249 |     float area_bbox = bbox[2] * bbox[3];
250 | 
251 |     Eigen::Matrix < float, -1, 2 > candidates_tl;
252 |     Eigen::Matrix < float, -1, 2 > candidates_br;
253 |     candidates_tl = candidates.leftCols(2);
254 |     candidates_br = candidates.rightCols(2) + candidates_tl;
255 | 
256 |     int size = int (candidates.rows());
257 |     //    Eigen::VectorXf area_intersection(size);
258 |     //    Eigen::VectorXf area_candidates(size);
259 |     Eigen::VectorXf res(size);
260 |     for (int i = 0; i < size; i++) {
261 |         float tl_1 = std::max(bbox_tl_1, candidates_tl(i, 0));
262 |         float tl_2 = std::max(bbox_tl_2, candidates_tl(i, 1));
263 |         float br_1 = std::min(bbox_br_1, candidates_br(i, 0));
264 |         float br_2 = std::min(bbox_br_2, candidates_br(i, 1));
265 | 
266 |         float w = br_1 - tl_1; w = (w < 0 ? 0 : w);
267 |         float h = br_2 - tl_2; h = (h < 0 ? 0 : h);
268 |         float area_intersection = w * h;
269 |         float area_candidates = candidates(i, 2) * candidates(i, 3);
270 |         res[i] = area_intersection / (area_bbox + area_candidates - area_intersection);
271 |     }
272 |     return res;
273 | }
274 | 


--------------------------------------------------------------------------------
/include/munkres.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *   Copyright (c) 2007 John Weaver
  3 |  *   Copyright (c) 2015 Miroslav Krajicek
  4 |  *
  5 |  *   This program is free software; you can redistribute it and/or modify
  6 |  *   it under the terms of the GNU General Public License as published by
  7 |  *   the Free Software Foundation; either version 2 of the License, or
  8 |  *   (at your option) any later version.
  9 |  *
 10 |  *   This program is distributed in the hope that it will be useful,
 11 |  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |  *   GNU General Public License for more details.
 14 |  *
 15 |  *   You should have received a copy of the GNU General Public License
 16 |  *   along with this program; if not, write to the Free Software
 17 |  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 18 |  */
 19 | 
 20 | #if !defined(_MUNKRES_H_)
 21 | #define _MUNKRES_H_
 22 | 
 23 | #include "matrix.h"
 24 | 
 25 | #include <list>
 26 | #include <utility>
 27 | #include <iostream>
 28 | #include <cmath>
 29 | #include <limits>
 30 | 
 31 | 
 32 | template<typename Data> class Munkres
 33 | {
 34 |     static constexpr int NORMAL = 0;
 35 |     static constexpr int STAR   = 1;
 36 |     static constexpr int PRIME  = 2;
 37 | public:
 38 | 
 39 |     /*
 40 |      *
 41 |      * Linear assignment problem solution
 42 |      * [modifies matrix in-place.]
 43 |      * matrix(row,col): row major format assumed.
 44 |      *
 45 |      * Assignments are remaining 0 values
 46 |      * (extra 0 values are replaced with -1)
 47 |      *
 48 |      */
 49 |     void solve(Matrix<Data> &m) {
 50 |         const size_t rows = m.rows(),
 51 |                 columns = m.columns(),
 52 |                 size = XYZMAX(rows, columns);
 53 | 
 54 | #ifdef DEBUG
 55 |         std::cout << "Munkres input: " << m << std::endl;
 56 | #endif
 57 | 
 58 |         // Copy input matrix
 59 |         this->matrix = m;
 60 | 
 61 |         if ( rows != columns ) {
 62 |             // If the input matrix isn't square, make it square
 63 |             // and fill the empty values with the largest value present
 64 |             // in the matrix.
 65 |             matrix.resize(size, size, matrix.mmax());
 66 |         }
 67 | 
 68 | 
 69 |         // STAR == 1 == starred, PRIME == 2 == primed
 70 |         mask_matrix.resize(size, size);
 71 | 
 72 |         row_mask = new bool[size];
 73 |         col_mask = new bool[size];
 74 |         for ( size_t i = 0 ; i < size ; i++ ) {
 75 |             row_mask[i] = false;
 76 |         }
 77 | 
 78 |         for ( size_t i = 0 ; i < size ; i++ ) {
 79 |             col_mask[i] = false;
 80 |         }
 81 | 
 82 |         // Prepare the matrix values...
 83 | 
 84 |         // If there were any infinities, replace them with a value greater
 85 |         // than the maximum value in the matrix.
 86 |         replace_infinites(matrix);
 87 | 
 88 |         minimize_along_direction(matrix, rows >= columns);
 89 |         minimize_along_direction(matrix, rows <  columns);
 90 | 
 91 |         // Follow the steps
 92 |         int step = 1;
 93 |         while ( step ) {
 94 |             switch ( step ) {
 95 |             case 1:
 96 |                 step = step1();
 97 |                 // step is always 2
 98 |                 break;
 99 |             case 2:
100 |                 step = step2();
101 |                 // step is always either 0 or 3
102 |                 break;
103 |             case 3:
104 |                 step = step3();
105 |                 // step in [3, 4, 5]
106 |                 break;
107 |             case 4:
108 |                 step = step4();
109 |                 // step is always 2
110 |                 break;
111 |             case 5:
112 |                 step = step5();
113 |                 // step is always 3
114 |                 break;
115 |             }
116 |         }
117 | 
118 |         // Store results
119 |         for ( size_t row = 0 ; row < size ; row++ ) {
120 |             for ( size_t col = 0 ; col < size ; col++ ) {
121 |                 if ( mask_matrix(row, col) == STAR ) {
122 |                     matrix(row, col) = 0;
123 |                 } else {
124 |                     matrix(row, col) = -1;
125 |                 }
126 |             }
127 |         }
128 | 
129 | #ifdef DEBUG
130 |         std::cout << "Munkres output: " << matrix << std::endl;
131 | #endif
132 |         // Remove the excess rows or columns that we added to fit the
133 |         // input to a square matrix.
134 |         matrix.resize(rows, columns);
135 | 
136 |         m = matrix;
137 | 
138 |         delete [] row_mask;
139 |         delete [] col_mask;
140 |     }
141 | 
142 |     static void replace_infinites(Matrix<Data> &matrix) {
143 |       const size_t rows = matrix.rows(),
144 |                 columns = matrix.columns();
145 |       //assert( rows > 0 && columns > 0 );
146 |       double max = matrix(0, 0);
147 |       constexpr auto infinity = std::numeric_limits<double>::infinity();
148 | 
149 |       // Find the greatest value in the matrix that isn't infinity.
150 |       for ( size_t row = 0 ; row < rows ; row++ ) {
151 |         for ( size_t col = 0 ; col < columns ; col++ ) {
152 |           if ( matrix(row, col) != infinity ) {
153 |             if ( max == infinity ) {
154 |               max = matrix(row, col);
155 |             } else {
156 |               max = XYZMAX(max, matrix(row, col));
157 |             }
158 |           }
159 |         }
160 |       }
161 | 
162 |       // a value higher than the maximum value present in the matrix.
163 |       if ( max == infinity ) {
164 |         // This case only occurs when all values are infinite.
165 |         max = 0;
166 |       } else {
167 |         max++;
168 |       }
169 | 
170 |       for ( size_t row = 0 ; row < rows ; row++ ) {
171 |         for ( size_t col = 0 ; col < columns ; col++ ) {
172 |           if ( matrix(row, col) == infinity ) {
173 |             matrix(row, col) = max;
174 |           }
175 |         }
176 |       }
177 | 
178 |     }
179 |     static void minimize_along_direction(Matrix<Data> &matrix, const bool over_columns) {
180 |       const size_t outer_size = over_columns ? matrix.columns() : matrix.rows(),
181 |                    inner_size = over_columns ? matrix.rows() : matrix.columns();
182 | 
183 |       // Look for a minimum value to subtract from all values along
184 |       // the "outer" direction.
185 |       for ( size_t i = 0 ; i < outer_size ; i++ ) {
186 |         double min = over_columns ? matrix(0, i) : matrix(i, 0);
187 | 
188 |         // As long as the current minimum is greater than zero,
189 |         // keep looking for the minimum.
190 |         // Start at one because we already have the 0th value in min.
191 |         for ( size_t j = 1 ; j < inner_size && min > 0 ; j++ ) {
192 |           min = XYZMIN(
193 |             min,
194 |             over_columns ? matrix(j, i) : matrix(i, j));
195 |         }
196 | 
197 |         if ( min > 0 ) {
198 |           for ( size_t j = 0 ; j < inner_size ; j++ ) {
199 |             if ( over_columns ) {
200 |               matrix(j, i) -= min;
201 |             } else {
202 |               matrix(i, j) -= min;
203 |             }
204 |           }
205 |         }
206 |       }
207 |     }
208 | 
209 | private:
210 | 
211 |   inline bool find_uncovered_in_matrix(const double item, size_t &row, size_t &col) const {
212 |     const size_t rows = matrix.rows(),
213 |               columns = matrix.columns();
214 | 
215 |     for ( row = 0 ; row < rows ; row++ ) {
216 |       if ( !row_mask[row] ) {
217 |         for ( col = 0 ; col < columns ; col++ ) {
218 |           if ( !col_mask[col] ) {
219 |             if ( matrix(row,col) == item ) {
220 |               return true;
221 |             }
222 |           }
223 |         }
224 |       }
225 |     }
226 | 
227 |     return false;
228 |   }
229 | 
230 |   bool pair_in_list(const std::pair<size_t,size_t> &needle, const std::list<std::pair<size_t,size_t> > &haystack) {
231 |     for ( std::list<std::pair<size_t,size_t> >::const_iterator i = haystack.begin() ; i != haystack.end() ; i++ ) {
232 |       if ( needle == *i ) {
233 |         return true;
234 |       }
235 |     }
236 | 
237 |     return false;
238 |   }
239 | 
240 |   int step1() {
241 |     const size_t rows = matrix.rows(),
242 |               columns = matrix.columns();
243 | 
244 |     for ( size_t row = 0 ; row < rows ; row++ ) {
245 |       for ( size_t col = 0 ; col < columns ; col++ ) {
246 |         if ( 0 == matrix(row, col) ) {
247 |           for ( size_t nrow = 0 ; nrow < row ; nrow++ )
248 |             if ( STAR == mask_matrix(nrow,col) )
249 |               goto next_column;
250 | 
251 |           mask_matrix(row,col) = STAR;
252 |           goto next_row;
253 |         }
254 |         next_column:;
255 |       }
256 |       next_row:;
257 |     }
258 | 
259 |     return 2;
260 |   }
261 | 
262 |   int step2() {
263 |     const size_t rows = matrix.rows(),
264 |               columns = matrix.columns();
265 |     size_t covercount = 0;
266 | 
267 |     for ( size_t row = 0 ; row < rows ; row++ )
268 |       for ( size_t col = 0 ; col < columns ; col++ )
269 |         if ( STAR == mask_matrix(row, col) ) {
270 |           col_mask[col] = true;
271 |           covercount++;
272 |         }
273 | 
274 |     if ( covercount >= matrix.minsize() ) {
275 |   #ifdef DEBUG
276 |       std::cout << "Final cover count: " << covercount << std::endl;
277 |   #endif
278 |       return 0;
279 |     }
280 | 
281 |   #ifdef DEBUG
282 |     std::cout << "Munkres matrix has " << covercount << " of " << matrix.minsize() << " Columns covered:" << std::endl;
283 |     std::cout << matrix << std::endl;
284 |   #endif
285 | 
286 | 
287 |     return 3;
288 |   }
289 | 
290 |   int step3() {
291 |     /*
292 |     Main Zero Search
293 | 
294 |      1. Find an uncovered Z in the distance matrix and prime it. If no such zero exists, go to Step 5
295 |      2. If No Z* exists in the row of the Z', go to Step 4.
296 |      3. If a Z* exists, cover this row and uncover the column of the Z*. Return to Step 3.1 to find a new Z
297 |     */
298 |     if ( find_uncovered_in_matrix(0, saverow, savecol) ) {
299 |       mask_matrix(saverow,savecol) = PRIME; // prime it.
300 |     } else {
301 |       return 5;
302 |     }
303 | 
304 |     for ( size_t ncol = 0 ; ncol < matrix.columns() ; ncol++ ) {
305 |       if ( mask_matrix(saverow,ncol) == STAR ) {
306 |         row_mask[saverow] = true; //cover this row and
307 |         col_mask[ncol] = false; // uncover the column containing the starred zero
308 |         return 3; // repeat
309 |       }
310 |     }
311 | 
312 |     return 4; // no starred zero in the row containing this primed zero
313 |   }
314 | 
315 |   int step4() {
316 |     const size_t rows = matrix.rows(),
317 |               columns = matrix.columns();
318 | 
319 |     // seq contains pairs of row/column values where we have found
320 |     // either a star or a prime that is part of the ``alternating sequence``.
321 |     std::list<std::pair<size_t,size_t> > seq;
322 |     // use saverow, savecol from step 3.
323 |     std::pair<size_t,size_t> z0(saverow, savecol);
324 |     seq.insert(seq.end(), z0);
325 | 
326 |     // We have to find these two pairs:
327 |     std::pair<size_t,size_t> z1(-1, -1);
328 |     std::pair<size_t,size_t> z2n(-1, -1);
329 | 
330 |     size_t row, col = savecol;
331 |     /*
332 |     Increment Set of Starred Zeros
333 | 
334 |      1. Construct the ``alternating sequence'' of primed and starred zeros:
335 | 
336 |            Z0 : Unpaired Z' from Step 4.2
337 |            Z1 : The Z* in the column of Z0
338 |            Z[2N] : The Z' in the row of Z[2N-1], if such a zero exists
339 |            Z[2N+1] : The Z* in the column of Z[2N]
340 | 
341 |         The sequence eventually terminates with an unpaired Z' = Z[2N] for some N.
342 |     */
343 |     bool madepair;
344 |     do {
345 |       madepair = false;
346 |       for ( row = 0 ; row < rows ; row++ ) {
347 |         if ( mask_matrix(row,col) == STAR ) {
348 |           z1.first = row;
349 |           z1.second = col;
350 |           if ( pair_in_list(z1, seq) ) {
351 |             continue;
352 |           }
353 | 
354 |           madepair = true;
355 |           seq.insert(seq.end(), z1);
356 |           break;
357 |         }
358 |       }
359 | 
360 |       if ( !madepair )
361 |         break;
362 | 
363 |       madepair = false;
364 | 
365 |       for ( col = 0 ; col < columns ; col++ ) {
366 |         if ( mask_matrix(row, col) == PRIME ) {
367 |           z2n.first = row;
368 |           z2n.second = col;
369 |           if ( pair_in_list(z2n, seq) ) {
370 |             continue;
371 |           }
372 |           madepair = true;
373 |           seq.insert(seq.end(), z2n);
374 |           break;
375 |         }
376 |       }
377 |     } while ( madepair );
378 | 
379 |     for ( std::list<std::pair<size_t,size_t> >::iterator i = seq.begin() ;
380 |         i != seq.end() ;
381 |         i++ ) {
382 |       // 2. Unstar each starred zero of the sequence.
383 |       if ( mask_matrix(i->first,i->second) == STAR )
384 |         mask_matrix(i->first,i->second) = NORMAL;
385 | 
386 |       // 3. Star each primed zero of the sequence,
387 |       // thus increasing the number of starred zeros by one.
388 |       if ( mask_matrix(i->first,i->second) == PRIME )
389 |         mask_matrix(i->first,i->second) = STAR;
390 |     }
391 | 
392 |     // 4. Erase all primes, uncover all columns and rows,
393 |     for ( size_t row = 0 ; row < mask_matrix.rows() ; row++ ) {
394 |       for ( size_t col = 0 ; col < mask_matrix.columns() ; col++ ) {
395 |         if ( mask_matrix(row,col) == PRIME ) {
396 |           mask_matrix(row,col) = NORMAL;
397 |         }
398 |       }
399 |     }
400 | 
401 |     for ( size_t i = 0 ; i < rows ; i++ ) {
402 |       row_mask[i] = false;
403 |     }
404 | 
405 |     for ( size_t i = 0 ; i < columns ; i++ ) {
406 |       col_mask[i] = false;
407 |     }
408 | 
409 |     // and return to Step 2.
410 |     return 2;
411 |   }
412 | 
413 |   int step5() {
414 |     const size_t rows = matrix.rows(),
415 |               columns = matrix.columns();
416 |     /*
417 |     New Zero Manufactures
418 | 
419 |      1. Let h be the smallest uncovered entry in the (modified) distance matrix.
420 |      2. Add h to all covered rows.
421 |      3. Subtract h from all uncovered columns
422 |      4. Return to Step 3, without altering stars, primes, or covers.
423 |     */
424 | 	double h = 100000;//xyzoylz std::numeric_limits<double>::max();
425 |     for ( size_t row = 0 ; row < rows ; row++ ) {
426 |       if ( !row_mask[row] ) {
427 |         for ( size_t col = 0 ; col < columns ; col++ ) {
428 |           if ( !col_mask[col] ) {
429 |             if ( h > matrix(row, col) && matrix(row, col) != 0 ) {
430 |               h = matrix(row, col);
431 |             }
432 |           }
433 |         }
434 |       }
435 |     }
436 | 
437 |     for ( size_t row = 0 ; row < rows ; row++ ) {
438 |       if ( row_mask[row] ) {
439 |         for ( size_t col = 0 ; col < columns ; col++ ) {
440 |           matrix(row, col) += h;
441 |         }
442 |       }
443 |     }
444 | 
445 |     for ( size_t col = 0 ; col < columns ; col++ ) {
446 |       if ( !col_mask[col] ) {
447 |         for ( size_t row = 0 ; row < rows ; row++ ) {
448 |           matrix(row, col) -= h;
449 |         }
450 |       }
451 |     }
452 | 
453 |     return 3;
454 |   }
455 | 
456 |   Matrix<int> mask_matrix;
457 |   Matrix<Data> matrix;
458 |   bool *row_mask;
459 |   bool *col_mask;
460 |   size_t saverow = 0, savecol = 0;
461 | };
462 | 
463 | 
464 | #endif /* !defined(_MUNKRES_H_) */
465 | 


--------------------------------------------------------------------------------
/include/logging.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | #ifndef TENSORRT_LOGGING_H
 18 | #define TENSORRT_LOGGING_H
 19 | 
 20 | #include "NvInferRuntimeCommon.h"
 21 | #include <cassert>
 22 | #include <ctime>
 23 | #include <iomanip>
 24 | #include <iostream>
 25 | #include <ostream>
 26 | #include <sstream>
 27 | #include <string>
 28 | 
 29 | using Severity = nvinfer1::ILogger::Severity;
 30 | 
 31 | class LogStreamConsumerBuffer : public std::stringbuf
 32 | {
 33 | public:
 34 |     LogStreamConsumerBuffer(std::ostream& stream, const std::string& prefix, bool shouldLog)
 35 |         : mOutput(stream)
 36 |         , mPrefix(prefix)
 37 |         , mShouldLog(shouldLog)
 38 |     {
 39 |     }
 40 | 
 41 |     LogStreamConsumerBuffer(LogStreamConsumerBuffer&& other)
 42 |         : mOutput(other.mOutput)
 43 |     {
 44 |     }
 45 | 
 46 |     ~LogStreamConsumerBuffer()
 47 |     {
 48 |         // std::streambuf::pbase() gives a pointer to the beginning of the buffered part of the output sequence
 49 |         // std::streambuf::pptr() gives a pointer to the current position of the output sequence
 50 |         // if the pointer to the beginning is not equal to the pointer to the current position,
 51 |         // call putOutput() to log the output to the stream
 52 |         if (pbase() != pptr())
 53 |         {
 54 |             putOutput();
 55 |         }
 56 |     }
 57 | 
 58 |     // synchronizes the stream buffer and returns 0 on success
 59 |     // synchronizing the stream buffer consists of inserting the buffer contents into the stream,
 60 |     // resetting the buffer and flushing the stream
 61 |     virtual int sync()
 62 |     {
 63 |         putOutput();
 64 |         return 0;
 65 |     }
 66 | 
 67 |     void putOutput()
 68 |     {
 69 |         if (mShouldLog)
 70 |         {
 71 |             // prepend timestamp
 72 |             std::time_t timestamp = std::time(nullptr);
 73 |             tm* tm_local = std::localtime(&timestamp);
 74 |             std::cout << "[";
 75 |             std::cout << std::setw(2) << std::setfill('0') << 1 + tm_local->tm_mon << "/";
 76 |             std::cout << std::setw(2) << std::setfill('0') << tm_local->tm_mday << "/";
 77 |             std::cout << std::setw(4) << std::setfill('0') << 1900 + tm_local->tm_year << "-";
 78 |             std::cout << std::setw(2) << std::setfill('0') << tm_local->tm_hour << ":";
 79 |             std::cout << std::setw(2) << std::setfill('0') << tm_local->tm_min << ":";
 80 |             std::cout << std::setw(2) << std::setfill('0') << tm_local->tm_sec << "] ";
 81 |             // std::stringbuf::str() gets the string contents of the buffer
 82 |             // insert the buffer contents pre-appended by the appropriate prefix into the stream
 83 |             mOutput << mPrefix << str();
 84 |             // set the buffer to empty
 85 |             str("");
 86 |             // flush the stream
 87 |             mOutput.flush();
 88 |         }
 89 |     }
 90 | 
 91 |     void setShouldLog(bool shouldLog)
 92 |     {
 93 |         mShouldLog = shouldLog;
 94 |     }
 95 | 
 96 | private:
 97 |     std::ostream& mOutput;
 98 |     std::string mPrefix;
 99 |     bool mShouldLog;
100 | };
101 | 
102 | //!
103 | //! \class LogStreamConsumerBase
104 | //! \brief Convenience object used to initialize LogStreamConsumerBuffer before std::ostream in LogStreamConsumer
105 | //!
106 | class LogStreamConsumerBase
107 | {
108 | public:
109 |     LogStreamConsumerBase(std::ostream& stream, const std::string& prefix, bool shouldLog)
110 |         : mBuffer(stream, prefix, shouldLog)
111 |     {
112 |     }
113 | 
114 | protected:
115 |     LogStreamConsumerBuffer mBuffer;
116 | };
117 | 
118 | //!
119 | //! \class LogStreamConsumer
120 | //! \brief Convenience object used to facilitate use of C++ stream syntax when logging messages.
121 | //!  Order of base classes is LogStreamConsumerBase and then std::ostream.
122 | //!  This is because the LogStreamConsumerBase class is used to initialize the LogStreamConsumerBuffer member field
123 | //!  in LogStreamConsumer and then the address of the buffer is passed to std::ostream.
124 | //!  This is necessary to prevent the address of an uninitialized buffer from being passed to std::ostream.
125 | //!  Please do not change the order of the parent classes.
126 | //!
127 | class LogStreamConsumer : protected LogStreamConsumerBase, public std::ostream
128 | {
129 | public:
130 |     //! \brief Creates a LogStreamConsumer which logs messages with level severity.
131 |     //!  Reportable severity determines if the messages are severe enough to be logged.
132 |     LogStreamConsumer(Severity reportableSeverity, Severity severity)
133 |         : LogStreamConsumerBase(severityOstream(severity), severityPrefix(severity), severity <= reportableSeverity)
134 |         , std::ostream(&mBuffer) // links the stream buffer with the stream
135 |         , mShouldLog(severity <= reportableSeverity)
136 |         , mSeverity(severity)
137 |     {
138 |     }
139 | 
140 |     LogStreamConsumer(LogStreamConsumer&& other)
141 |         : LogStreamConsumerBase(severityOstream(other.mSeverity), severityPrefix(other.mSeverity), other.mShouldLog)
142 |         , std::ostream(&mBuffer) // links the stream buffer with the stream
143 |         , mShouldLog(other.mShouldLog)
144 |         , mSeverity(other.mSeverity)
145 |     {
146 |     }
147 | 
148 |     void setReportableSeverity(Severity reportableSeverity)
149 |     {
150 |         mShouldLog = mSeverity <= reportableSeverity;
151 |         mBuffer.setShouldLog(mShouldLog);
152 |     }
153 | 
154 | private:
155 |     static std::ostream& severityOstream(Severity severity)
156 |     {
157 |         return severity >= Severity::kINFO ? std::cout : std::cerr;
158 |     }
159 | 
160 |     static std::string severityPrefix(Severity severity)
161 |     {
162 |         switch (severity)
163 |         {
164 |         case Severity::kINTERNAL_ERROR: return "[F] ";
165 |         case Severity::kERROR: return "[E] ";
166 |         case Severity::kWARNING: return "[W] ";
167 |         case Severity::kINFO: return "[I] ";
168 |         case Severity::kVERBOSE: return "[V] ";
169 |         default: assert(0); return "";
170 |         }
171 |     }
172 | 
173 |     bool mShouldLog;
174 |     Severity mSeverity;
175 | };
176 | 
177 | //! \class Logger
178 | //!
179 | //! \brief Class which manages logging of TensorRT tools and samples
180 | //!
181 | //! \details This class provides a common interface for TensorRT tools and samples to log information to the console,
182 | //! and supports logging two types of messages:
183 | //!
184 | //! - Debugging messages with an associated severity (info, warning, error, or internal error/fatal)
185 | //! - Test pass/fail messages
186 | //!
187 | //! The advantage of having all samples use this class for logging as opposed to emitting directly to stdout/stderr is
188 | //! that the logic for controlling the verbosity and formatting of sample output is centralized in one location.
189 | //!
190 | //! In the future, this class could be extended to support dumping test results to a file in some standard format
191 | //! (for example, JUnit XML), and providing additional metadata (e.g. timing the duration of a test run).
192 | //!
193 | //! TODO: For backwards compatibility with existing samples, this class inherits directly from the nvinfer1::ILogger
194 | //! interface, which is problematic since there isn't a clean separation between messages coming from the TensorRT
195 | //! library and messages coming from the sample.
196 | //!
197 | //! In the future (once all samples are updated to use Logger::getTRTLogger() to access the ILogger) we can refactor the
198 | //! class to eliminate the inheritance and instead make the nvinfer1::ILogger implementation a member of the Logger
199 | //! object.
200 | 
201 | class Logger : public nvinfer1::ILogger
202 | {
203 | public:
204 |     Logger(Severity severity = Severity::kWARNING)
205 |         : mReportableSeverity(severity)
206 |     {
207 |     }
208 | 
209 |     //!
210 |     //! \enum TestResult
211 |     //! \brief Represents the state of a given test
212 |     //!
213 |     enum class TestResult
214 |     {
215 |         kRUNNING, //!< The test is running
216 |         kPASSED,  //!< The test passed
217 |         kFAILED,  //!< The test failed
218 |         kWAIVED   //!< The test was waived
219 |     };
220 | 
221 |     //!
222 |     //! \brief Forward-compatible method for retrieving the nvinfer::ILogger associated with this Logger
223 |     //! \return The nvinfer1::ILogger associated with this Logger
224 |     //!
225 |     //! TODO Once all samples are updated to use this method to register the logger with TensorRT,
226 |     //! we can eliminate the inheritance of Logger from ILogger
227 |     //!
228 |     nvinfer1::ILogger& getTRTLogger()
229 |     {
230 |         return *this;
231 |     }
232 | 
233 |     //!
234 |     //! \brief Implementation of the nvinfer1::ILogger::log() virtual method
235 |     //!
236 |     //! Note samples should not be calling this function directly; it will eventually go away once we eliminate the
237 |     //! inheritance from nvinfer1::ILogger
238 |     //!
239 |     void log(Severity severity, const char* msg) override
240 |     {
241 |         LogStreamConsumer(mReportableSeverity, severity) << "[TRT] " << std::string(msg) << std::endl;
242 |     }
243 | 
244 |     //!
245 |     //! \brief Method for controlling the verbosity of logging output
246 |     //!
247 |     //! \param severity The logger will only emit messages that have severity of this level or higher.
248 |     //!
249 |     void setReportableSeverity(Severity severity)
250 |     {
251 |         mReportableSeverity = severity;
252 |     }
253 | 
254 |     //!
255 |     //! \brief Opaque handle that holds logging information for a particular test
256 |     //!
257 |     //! This object is an opaque handle to information used by the Logger to print test results.
258 |     //! The sample must call Logger::defineTest() in order to obtain a TestAtom that can be used
259 |     //! with Logger::reportTest{Start,End}().
260 |     //!
261 |     class TestAtom
262 |     {
263 |     public:
264 |         TestAtom(TestAtom&&) = default;
265 | 
266 |     private:
267 |         friend class Logger;
268 | 
269 |         TestAtom(bool started, const std::string& name, const std::string& cmdline)
270 |             : mStarted(started)
271 |             , mName(name)
272 |             , mCmdline(cmdline)
273 |         {
274 |         }
275 | 
276 |         bool mStarted;
277 |         std::string mName;
278 |         std::string mCmdline;
279 |     };
280 | 
281 |     //!
282 |     //! \brief Define a test for logging
283 |     //!
284 |     //! \param[in] name The name of the test.  This should be a string starting with
285 |     //!                  "TensorRT" and containing dot-separated strings containing
286 |     //!                  the characters [A-Za-z0-9_].
287 |     //!                  For example, "TensorRT.sample_googlenet"
288 |     //! \param[in] cmdline The command line used to reproduce the test
289 |     //
290 |     //! \return a TestAtom that can be used in Logger::reportTest{Start,End}().
291 |     //!
292 |     static TestAtom defineTest(const std::string& name, const std::string& cmdline)
293 |     {
294 |         return TestAtom(false, name, cmdline);
295 |     }
296 | 
297 |     //!
298 |     //! \brief A convenience overloaded version of defineTest() that accepts an array of command-line arguments
299 |     //!        as input
300 |     //!
301 |     //! \param[in] name The name of the test
302 |     //! \param[in] argc The number of command-line arguments
303 |     //! \param[in] argv The array of command-line arguments (given as C strings)
304 |     //!
305 |     //! \return a TestAtom that can be used in Logger::reportTest{Start,End}().
306 |     static TestAtom defineTest(const std::string& name, int argc, char const* const* argv)
307 |     {
308 |         auto cmdline = genCmdlineString(argc, argv);
309 |         return defineTest(name, cmdline);
310 |     }
311 | 
312 |     //!
313 |     //! \brief Report that a test has started.
314 |     //!
315 |     //! \pre reportTestStart() has not been called yet for the given testAtom
316 |     //!
317 |     //! \param[in] testAtom The handle to the test that has started
318 |     //!
319 |     static void reportTestStart(TestAtom& testAtom)
320 |     {
321 |         reportTestResult(testAtom, TestResult::kRUNNING);
322 |         assert(!testAtom.mStarted);
323 |         testAtom.mStarted = true;
324 |     }
325 | 
326 |     //!
327 |     //! \brief Report that a test has ended.
328 |     //!
329 |     //! \pre reportTestStart() has been called for the given testAtom
330 |     //!
331 |     //! \param[in] testAtom The handle to the test that has ended
332 |     //! \param[in] result The result of the test. Should be one of TestResult::kPASSED,
333 |     //!                   TestResult::kFAILED, TestResult::kWAIVED
334 |     //!
335 |     static void reportTestEnd(const TestAtom& testAtom, TestResult result)
336 |     {
337 |         assert(result != TestResult::kRUNNING);
338 |         assert(testAtom.mStarted);
339 |         reportTestResult(testAtom, result);
340 |     }
341 | 
342 |     static int reportPass(const TestAtom& testAtom)
343 |     {
344 |         reportTestEnd(testAtom, TestResult::kPASSED);
345 |         return EXIT_SUCCESS;
346 |     }
347 | 
348 |     static int reportFail(const TestAtom& testAtom)
349 |     {
350 |         reportTestEnd(testAtom, TestResult::kFAILED);
351 |         return EXIT_FAILURE;
352 |     }
353 | 
354 |     static int reportWaive(const TestAtom& testAtom)
355 |     {
356 |         reportTestEnd(testAtom, TestResult::kWAIVED);
357 |         return EXIT_SUCCESS;
358 |     }
359 | 
360 |     static int reportTest(const TestAtom& testAtom, bool pass)
361 |     {
362 |         return pass ? reportPass(testAtom) : reportFail(testAtom);
363 |     }
364 | 
365 |     Severity getReportableSeverity() const
366 |     {
367 |         return mReportableSeverity;
368 |     }
369 | 
370 | private:
371 |     //!
372 |     //! \brief returns an appropriate string for prefixing a log message with the given severity
373 |     //!
374 |     static const char* severityPrefix(Severity severity)
375 |     {
376 |         switch (severity)
377 |         {
378 |         case Severity::kINTERNAL_ERROR: return "[F] ";
379 |         case Severity::kERROR: return "[E] ";
380 |         case Severity::kWARNING: return "[W] ";
381 |         case Severity::kINFO: return "[I] ";
382 |         case Severity::kVERBOSE: return "[V] ";
383 |         default: assert(0); return "";
384 |         }
385 |     }
386 | 
387 |     //!
388 |     //! \brief returns an appropriate string for prefixing a test result message with the given result
389 |     //!
390 |     static const char* testResultString(TestResult result)
391 |     {
392 |         switch (result)
393 |         {
394 |         case TestResult::kRUNNING: return "RUNNING";
395 |         case TestResult::kPASSED: return "PASSED";
396 |         case TestResult::kFAILED: return "FAILED";
397 |         case TestResult::kWAIVED: return "WAIVED";
398 |         default: assert(0); return "";
399 |         }
400 |     }
401 | 
402 |     //!
403 |     //! \brief returns an appropriate output stream (cout or cerr) to use with the given severity
404 |     //!
405 |     static std::ostream& severityOstream(Severity severity)
406 |     {
407 |         return severity >= Severity::kINFO ? std::cout : std::cerr;
408 |     }
409 | 
410 |     //!
411 |     //! \brief method that implements logging test results
412 |     //!
413 |     static void reportTestResult(const TestAtom& testAtom, TestResult result)
414 |     {
415 |         severityOstream(Severity::kINFO) << "&&&& " << testResultString(result) << " " << testAtom.mName << " # "
416 |                                          << testAtom.mCmdline << std::endl;
417 |     }
418 | 
419 |     //!
420 |     //! \brief generate a command line string from the given (argc, argv) values
421 |     //!
422 |     static std::string genCmdlineString(int argc, char const* const* argv)
423 |     {
424 |         std::stringstream ss;
425 |         for (int i = 0; i < argc; i++)
426 |         {
427 |             if (i > 0)
428 |                 ss << " ";
429 |             ss << argv[i];
430 |         }
431 |         return ss.str();
432 |     }
433 | 
434 |     Severity mReportableSeverity;
435 | };
436 | 
437 | namespace
438 | {
439 | 
440 | //!
441 | //! \brief produces a LogStreamConsumer object that can be used to log messages of severity kVERBOSE
442 | //!
443 | //! Example usage:
444 | //!
445 | //!     LOG_VERBOSE(logger) << "hello world" << std::endl;
446 | //!
447 | inline LogStreamConsumer LOG_VERBOSE(const Logger& logger)
448 | {
449 |     return LogStreamConsumer(logger.getReportableSeverity(), Severity::kVERBOSE);
450 | }
451 | 
452 | //!
453 | //! \brief produces a LogStreamConsumer object that can be used to log messages of severity kINFO
454 | //!
455 | //! Example usage:
456 | //!
457 | //!     LOG_INFO(logger) << "hello world" << std::endl;
458 | //!
459 | inline LogStreamConsumer LOG_INFO(const Logger& logger)
460 | {
461 |     return LogStreamConsumer(logger.getReportableSeverity(), Severity::kINFO);
462 | }
463 | 
464 | //!
465 | //! \brief produces a LogStreamConsumer object that can be used to log messages of severity kWARNING
466 | //!
467 | //! Example usage:
468 | //!
469 | //!     LOG_WARN(logger) << "hello world" << std::endl;
470 | //!
471 | inline LogStreamConsumer LOG_WARN(const Logger& logger)
472 | {
473 |     return LogStreamConsumer(logger.getReportableSeverity(), Severity::kWARNING);
474 | }
475 | 
476 | //!
477 | //! \brief produces a LogStreamConsumer object that can be used to log messages of severity kERROR
478 | //!
479 | //! Example usage:
480 | //!
481 | //!     LOG_ERROR(logger) << "hello world" << std::endl;
482 | //!
483 | inline LogStreamConsumer LOG_ERROR(const Logger& logger)
484 | {
485 |     return LogStreamConsumer(logger.getReportableSeverity(), Severity::kERROR);
486 | }
487 | 
488 | //!
489 | //! \brief produces a LogStreamConsumer object that can be used to log messages of severity kINTERNAL_ERROR
490 | //         ("fatal" severity)
491 | //!
492 | //! Example usage:
493 | //!
494 | //!     LOG_FATAL(logger) << "hello world" << std::endl;
495 | //!
496 | inline LogStreamConsumer LOG_FATAL(const Logger& logger)
497 | {
498 |     return LogStreamConsumer(logger.getReportableSeverity(), Severity::kINTERNAL_ERROR);
499 | }
500 | 
501 | } // anonymous namespace
502 | 
503 | #endif // TENSORRT_LOGGING_H
504 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------