src/kcf.h

   1 #ifndef KCF_HEADER_6565467831231
   2 #define KCF_HEADER_6565467831231
   3
   4 #include <opencv2/opencv.hpp>
   5 #include <vector>
   6 #include <memory>
   7 #include "fhog.hpp"
   8
   9 #ifdef CUFFT
  10 #include "complexmat.cuh"
  11 #include "cuda_functions.cuh"
  12 #include "cuda/cuda_error_check.cuh"
  13 #include <cuda_runtime.h>
  14 #else
  15 #include "complexmat.hpp"
  16 #endif
  17
  18 #include "cnfeat.hpp"
  19 #include "fft.h"
  20 #include "threadctx.hpp"
  21 #include "pragmas.h"
  22
  23 struct BBox_c {
  24     double cx, cy, w, h, a;
  25
  26     inline void scale(double factor)
  27     {
  28         cx *= factor;
  29         cy *= factor;
  30         w *= factor;
  31         h *= factor;
  32     }
  33
  34     inline void scale_x(double factor)
  35     {
  36         cx *= factor;
  37         w *= factor;
  38     }
  39
  40     inline void scale_y(double factor)
  41     {
  42         cy *= factor;
  43         h *= factor;
  44     }
  45
  46     inline cv::Rect get_rect() { return cv::Rect(int(cx - w / 2.), int(cy - h / 2.), int(w), int(h)); }
  47 };
  48
  49 class KCF_Tracker {
  50   public:
  51     bool m_debug{false};
  52     bool m_visual_debug{false};
  53     bool m_use_scale{true};
  54     bool m_use_angle{false}; // Doesn't work with FFTW-BIG version
  55     bool m_use_color{true};
  56 #ifdef ASYNC
  57     bool m_use_multithreading{true};
  58 #else
  59     bool m_use_multithreading{false};
  60 #endif // ASYNC
  61     bool m_use_subpixel_localization{true};
  62     bool m_use_subgrid_scale{true};
  63     bool m_use_cnfeat{true};
  64     bool m_use_linearkernel{false};
  65 #ifdef BIG_BATCH
  66     bool m_use_big_batch{true};
  67 #else
  68     bool m_use_big_batch{false};
  69 #endif
  70 #ifdef CUFFT
  71     bool m_use_cuda{true};
  72 #else
  73     bool m_use_cuda{false};
  74 #endif
  75
  76     /*
  77     padding             ... extra area surrounding the target           (1.5)
  78     kernel_sigma        ... gaussian kernel bandwidth                   (0.5)
  79     lambda              ... regularization                              (1e-4)
  80     interp_factor       ... linear interpolation factor for adaptation  (0.02)
  81     output_sigma_factor ... spatial bandwidth (proportional to target)  (0.1)
  82     cell_size           ... hog cell size                               (4)
  83     */
  84     KCF_Tracker(double padding, double kernel_sigma, double lambda, double interp_factor, double output_sigma_factor,
  85                 int cell_size);
  86     KCF_Tracker();
  87     ~KCF_Tracker();
  88
  89     // Init/re-init methods
  90     void init(cv::Mat &img, const cv::Rect &bbox, int fit_size_x, int fit_size_y);
  91     void setTrackerPose(BBox_c &bbox, cv::Mat &img, int fit_size_x, int fit_size_y);
  92     void updateTrackerPosition(BBox_c &bbox);
  93
  94     // frame-to-frame object tracking
  95     void track(cv::Mat &img);
  96     BBox_c getBBox();
  97     double getFilterResponse() const; // Measure of tracking accuracy
  98
  99   private:
 100     Fft &fft;
 101
 102     BBox_c p_pose;
 103     double max_response = -1.;
 104
 105     bool p_resize_image = false;
 106     bool p_fit_to_pw2 = false;
 107
 108     const double p_downscale_factor = 0.5;
 109     double p_scale_factor_x = 1;
 110     double p_scale_factor_y = 1;
 111     const double p_floating_error = 0.0001;
 112
 113     double p_padding = 1.5;
 114     double p_output_sigma_factor = 0.1;
 115     double p_output_sigma;
 116     double p_kernel_sigma = 0.5;   // def = 0.5
 117     double p_lambda = 1e-4;        // regularization in learning step
 118     double p_interp_factor = 0.02; // def = 0.02, linear interpolation factor for adaptation
 119     int p_cell_size = 4;           // 4 for hog (= bin_size)
 120     cv::Size p_windows_size;
 121     uint p_num_scales {7};
 122     double p_scale_step = 1.02;
 123     double p_current_scale = 1.;
 124     double p_min_max_scale[2];
 125     std::vector<double> p_scales;
 126     int p_current_angle = 0;
 127     uint p_num_angles {5};
 128     int p_angle_min = -20, p_angle_max = 20;
 129     int p_angle_step = 10;
 130     std::vector<int> p_angles;
 131
 132     // for visual debug
 133     int p_debug_image_size = 100;
 134     std::vector<cv::Mat> p_debug_scale_responses;
 135     std::vector<cv::Mat> p_debug_subwindows;
 136
 137     //for big batch
 138     int p_num_of_feats = 31 + (m_use_color ? 3 : 0) + (m_use_cnfeat ? 10 : 0);
 139     cv::Size p_roi;
 140
 141     std::vector<ThreadCtx> p_threadctxs;
 142
 143     //CUDA compability
 144     cv::Mat p_rot_labels;
 145     DynMem p_rot_labels_data;
 146
 147     // model
 148     ComplexMat p_yf;
 149     ComplexMat p_model_alphaf;
 150     ComplexMat p_model_alphaf_num;
 151     ComplexMat p_model_alphaf_den;
 152     ComplexMat p_model_xf;
 153     ComplexMat p_xf;
 154     //helping functions
 155     void scale_track(ThreadCtx & vars, cv::Mat & input_rgb, cv::Mat & input_gray);
 156     cv::Mat get_subwindow(const cv::Mat & input, int cx, int cy, int size_x, int size_y);
 157     cv::Mat gaussian_shaped_labels(double sigma, int dim1, int dim2);
 158     void gaussian_correlation(struct ThreadCtx &vars, const ComplexMat &xf, const ComplexMat &yf, double sigma,
 159                               bool auto_correlation = false);
 160     cv::Mat circshift(const cv::Mat &patch, int x_rot, int y_rot);
 161     cv::Mat cosine_window_function(int dim1, int dim2);
 162     void get_features(cv::Mat &patch_rgb, cv::Mat &patch_gray, ThreadCtx &vars);
 163     void geometric_transformations(cv::Mat &patch, int size_x, int size_y, int angle = 0, bool allow_debug = true);
 164     cv::Point2f sub_pixel_peak(cv::Point &max_loc, cv::Mat &response);
 165     double sub_grid_scale(uint index);
 166 };
 167
 168 #endif // KCF_HEADER_6565467831231