Cleaned OpenCV version

All version now uses same minimal FFT API and workflow.
TODO Clean the scale_var and scale_vars_init, add support for big_batch
mode for FFTW and CUFFT, implement cuda streams.

diff --git a/src/fft_opencv.cpp b/src/fft_opencv.cpp
index c4249419ab3ab927d11726e2ba9ee17d3cb7aeb5..6c39c8317a87967022eb4cb1ad053e013912e1d7 100644 (file)
--- a/src/fft_opencv.cpp
+++ b/src/fft_opencv.cpp
@@ -15,48 +15,24 @@ void FftOpencv::set_window(const cv::Mat & window)
      m_window = window;
 }
 
-ComplexMat FftOpencv::forward(const cv::Mat & input)
-{
-    cv::Mat complex_result;
-    cv::dft(input, complex_result, cv::DFT_COMPLEX_OUTPUT);
-    return ComplexMat(complex_result);
-}
-
 void FftOpencv::forward(Scale_vars & vars)
 {
-    cv::Mat complex_result;
-    cv::dft(vars.in_all, complex_result, cv::DFT_COMPLEX_OUTPUT);
-    if (vars.flag & Tracker_flags::AUTO_CORRELATION)
-       vars.kf = ComplexMat(complex_result);
-    else
-        vars.kzf = ComplexMat(complex_result);
-    return;
-}
-
-ComplexMat FftOpencv::forward_raw(float *input, bool all_scales)
-{
-    ComplexMat dummy;
-    return dummy;
-}
-
-ComplexMat FftOpencv::forward_window(const std::vector<cv::Mat> & input)
-{
-    int n_channels = input.size();
-    ComplexMat result(input[0].rows, input[0].cols, n_channels);
+    ComplexMat *complex_result = vars.flag & Tracker_flags::TRACKER_INIT ? vars.p_yf_ptr :
+                                                  vars.flag & Tracker_flags::AUTO_CORRELATION ? & vars.kf : & vars.kzf;
+    cv::Mat *input = vars.flag & Tracker_flags::TRACKER_INIT ? & vars.rot_labels : & vars.in_all;
 
-    for (int i = 0; i < n_channels; ++i) {
-        cv::Mat complex_result;
-        cv::dft(input[i].mul(m_window), complex_result, cv::DFT_COMPLEX_OUTPUT);
-        result.set_channel(i, complex_result);
-    }
-    return result;
+    cv::Mat tmp;
+    cv::dft(*input, tmp, cv::DFT_COMPLEX_OUTPUT);
+    *complex_result = ComplexMat(tmp);
+    return;
 }
 
 void FftOpencv::forward_window(Scale_vars & vars)
 {
     int n_channels = vars.patch_feats.size();
 
-    ComplexMat *result = vars.flag & Tracker_flags::TRACKER_UPDATE ? & vars.xf : & vars.zf;
+    ComplexMat *result = vars.flag & Tracker_flags::TRACKER_INIT ? vars.p_model_xf_ptr :
+                                                  vars.flag & Tracker_flags::TRACKER_UPDATE ? & vars.xf : & vars.zf;
 
     for (int i = 0; i < n_channels; ++i) {
         cv::Mat complex_result;
@@ -66,22 +42,6 @@ void FftOpencv::forward_window(Scale_vars & vars)
     return;
 }
 
-cv::Mat FftOpencv::inverse(const ComplexMat & input)
-{
-    cv::Mat real_result;
-    if (input.n_channels == 1) {
-        cv::dft(input.to_cv_mat(), real_result, cv::DFT_INVERSE | cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
-    } else {
-        std::vector<cv::Mat> mat_channels = input.to_cv_mat_vector();
-        std::vector<cv::Mat> ifft_mats(input.n_channels);
-        for (int i = 0; i < input.n_channels; ++i) {
-            cv::dft(mat_channels[i], ifft_mats[i], cv::DFT_INVERSE | cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
-        }
-        cv::merge(ifft_mats, real_result);
-    }
-    return real_result;
-}
-
 void FftOpencv::inverse(Scale_vars & vars)
 {
     ComplexMat *input = vars.flag & Tracker_flags::RESPONSE ? & vars.kzf : & vars.xyf;
@@ -100,12 +60,5 @@ void FftOpencv::inverse(Scale_vars & vars)
     return;
 }
 
-float* FftOpencv::inverse_raw(const ComplexMat & input)
-{
-    return nullptr;
-}
-
 FftOpencv::~FftOpencv()
-{
-
-}
+{}

diff --git a/src/fft_opencv.h b/src/fft_opencv.h
index 92648c3614c3a16be444b6b952f4315c7c3bcdde..557cd0b428ecf4b82ea4317bab2f582a6260ce17 100644 (file)
--- a/src/fft_opencv.h
+++ b/src/fft_opencv.h
@@ -11,14 +11,9 @@ class FftOpencv : public Fft
 public:
     void init(unsigned width, unsigned height, unsigned num_of_feats, unsigned num_of_scales, bool big_batch_mode) override;
     void set_window(const cv::Mat & window) override;
-    ComplexMat forward(const cv::Mat & input) override;
     void forward(Scale_vars & vars) override;
-    ComplexMat forward_raw(float *input, bool all_scales) override;
-    ComplexMat forward_window(const std::vector<cv::Mat> & input) override;
     void forward_window(Scale_vars & vars) override;
-    cv::Mat inverse(const ComplexMat & input) override;
     void inverse(Scale_vars & vars) override;
-    float* inverse_raw(const ComplexMat & input) override;
     ~FftOpencv() override;
 private:
     cv::Mat m_window;

diff --git a/src/kcf.cpp b/src/kcf.cpp
index bb94a5390cbd770b0ece4464e1d6dc0b4aa1f878..831e70be10bd253a5a52783eaf0badd3a813ac1f 100644 (file)
--- a/src/kcf.cpp
+++ b/src/kcf.cpp
@@ -20,7 +20,7 @@
 #endif //OPENMP
 
 #define DEBUG_PRINT(obj) if (m_debug) {std::cout << #obj << " @" << __LINE__ << std::endl << (obj) << std::endl;}
-#define DEBUG_PRINTM(obj) if (m_debug) {std::cout << #obj << " @" << __LINE__ << " " << (obj).size() << " CH: " << (obj).channels() << std::endl << (obj) << std::endl;}
+#define DEBUG_PRINTM(obj) if (m_debug) {std::cout << #obj << " @" << __LINE__ << " " << (obj).size() << " CH: " << (obj).channels() << std::endl /*<< (obj) << std::endl*/;}
 
 KCF_Tracker::KCF_Tracker(double padding, double kernel_sigma, double lambda, double interp_factor, double output_sigma_factor, int cell_size) :
     fft(*new FFT()),
@@ -171,7 +171,6 @@ void KCF_Tracker::init(cv::Mat &img, const cv::Rect & bbox, int fit_size_x, int
     scale_vars[0].flag = Tracker_flags::TRACKER_INIT;
     //window weights, i.e. labels
     gaussian_shaped_labels(scale_vars[0], p_output_sigma, p_windows_size[0]/p_cell_size, p_windows_size[1]/p_cell_size);
-    DEBUG_PRINTM(scale_vars[0].rot_labels);
 
     fft.forward(scale_vars[0]);
     DEBUG_PRINTM(p_yf);
@@ -274,21 +273,26 @@ else
         scale_vars[i].yf_sqr_norm = (float*) malloc(sizeof(float));
 
         scale_vars[i].patch_feats.reserve(p_num_of_feats);
+
+        int height = p_windows_size[1]/p_cell_size;
 #ifdef FFTW
-        scale_vars[i].ifft2_res = cv::Mat(p_windows_size[1]/p_cell_size, p_windows_size[0]/p_cell_size, CV_32FC(p_num_of_feats));
-        scale_vars[i].response = cv::Mat(p_windows_size[1]/p_cell_size, p_windows_size[0]/p_cell_size, CV_32FC1);
+        int width = (p_windows_size[0]/p_cell_size)/2+1;
+#else
+        int width = p_windows_size[0]/p_cell_size;
+#endif
 
-        scale_vars[i].zf = ComplexMat(p_windows_size[1]/p_cell_size, (p_windows_size[0]/p_cell_size)/2+1, p_num_of_feats);
-        scale_vars[i].kzf = ComplexMat(p_windows_size[1]/p_cell_size, (p_windows_size[0]/p_cell_size)/2+1, 1);
-        scale_vars[i].kf = ComplexMat(p_windows_size[1]/p_cell_size, (p_windows_size[0]/p_cell_size)/2+1, 1);
+        scale_vars[i].ifft2_res = cv::Mat(height, p_windows_size[0]/p_cell_size, CV_32FC(p_num_of_feats));
+        scale_vars[i].response = cv::Mat(height, p_windows_size[0]/p_cell_size, CV_32FC1);
 
+        scale_vars[i].zf = ComplexMat(height, width, p_num_of_feats);
+        scale_vars[i].kzf = ComplexMat(height, width, 1);
+        scale_vars[i].kf = ComplexMat(height, width, 1);
+        scale_vars[i].rot_labels = cv::Mat(height, p_windows_size[0]/p_cell_size, CV_32FC1);
+#ifdef FFTW
         scale_vars[i].in_all = cv::Mat((p_windows_size[1]/p_cell_size)*p_num_of_feats, p_windows_size[0]/p_cell_size, CV_32F);
         scale_vars[i].fw_all = cv::Mat((p_windows_size[1]/p_cell_size)*p_num_of_feats, p_windows_size[0]/p_cell_size, CV_32F);
 #else
-        scale_vars[i].zf = ComplexMat(p_windows_size[1]/p_cell_size, p_windows_size[0]/p_cell_size, p_num_of_feats);
-        //We use scale_vars[0] for updating the tracker, so we only allocate memory for  its xf only.
-        if (i==0)
-            scale_vars[i].xf = ComplexMat(p_windows_size[1]/p_cell_size, p_windows_size[0]/p_cell_size, p_num_of_feats);
+        scale_vars[i].in_all = cv::Mat((p_windows_size[1]/p_cell_size), p_windows_size[0]/p_cell_size, CV_32F);
 #endif
     }
 #endif
@@ -300,6 +304,7 @@ else
 #else
     p_model_xf.create(p_windows_size[1]/p_cell_size, p_windows_size[0]/p_cell_size, p_num_of_feats);
     p_yf.create(p_windows_size[1]/p_cell_size, p_windows_size[0]/p_cell_size, 1);
+    scale_vars[0].xf = ComplexMat(p_windows_size[1]/p_cell_size, p_windows_size[0]/p_cell_size, p_num_of_feats);
 #endif
     scale_vars[0].p_model_xf_ptr = & p_model_xf;
     scale_vars[0].p_yf_ptr = & p_yf;