src/threadctx.hpp

   1 #ifndef SCALE_VARS_HPP
   2 #define SCALE_VARS_HPP
   3
   4 #include "dynmem.hpp"
   5
   6 #ifdef CUFFT
   7 #include "complexmat.cuh"
   8 #else
   9 #include "complexmat.hpp"
  10 #ifndef CUFFTW
  11 // For compatibility reasons between CuFFT and FFTW, OpenCVfft versions.
  12 typedef int *cudaStream_t;
  13 #endif
  14 #endif
  15
  16 struct ThreadCtx {
  17   public:
  18     ThreadCtx(cv::Size windows_size, uint cell_size, uint num_of_feats, uint num_of_scales = 1,
  19               ComplexMat *model_xf = nullptr, ComplexMat *yf = nullptr, bool zero_index = false)
  20     {
  21 #ifdef CUFFT
  22         if (zero_index) {
  23             cudaSetDeviceFlags(cudaDeviceMapHost);
  24             this->zero_index = true;
  25         }
  26
  27 #if defined(ASYNC) || defined(OPENMP)
  28         CudaSafeCall(cudaStreamCreate(&this->stream));
  29 #endif
  30
  31         this->patch_feats.reserve(uint(num_of_feats));
  32         // Size of cufftReal == float
  33         uint cells_size =
  34             ((uint(windows_size.width) / cell_size) * (uint(windows_size.height) / cell_size)) * sizeof(float);
  35
  36         this->data_i_1ch = DynMem(cells_size * num_of_scales);
  37         this->data_i_features = DynMem(cells_size * num_of_feats);
  38
  39         this->ifft2_res = cv::Mat(windows_size.height / int(cell_size), windows_size.width / int(cell_size),
  40                                   CV_32FC(int(num_of_feats)), this->data_i_features.hostMem());
  41         this->response = cv::Mat(windows_size.height / int(cell_size), windows_size.width / int(cell_size),
  42                                  CV_32FC(int(num_of_scales)), this->data_i_1ch.hostMem());
  43
  44         this->zf.create(uint(windows_size.height) / cell_size, (uint(windows_size.width) / cell_size) / 2 + 1,
  45                         num_of_feats, num_of_scales, this->stream);
  46         this->kzf.create(uint(windows_size.height) / cell_size, (uint(windows_size.width) / cell_size) / 2 + 1,
  47                          num_of_scales, this->stream);
  48         this->kf.create(uint(windows_size.height) / cell_size, (uint(windows_size.width) / cell_size) / 2 + 1,
  49                         num_of_scales, this->stream);
  50
  51         this->xf_sqr_norm = DynMem(num_of_scales * sizeof(float));
  52         this->yf_sqr_norm = DynMem(sizeof(float));
  53
  54         this->gauss_corr_res = DynMem(cells_size * num_of_scales);
  55         this->in_all = cv::Mat(windows_size.height / int(cell_size) * int(num_of_scales),
  56                                windows_size.width / int(cell_size), CV_32F, this->gauss_corr_res.hostMem());
  57
  58         if (zero_index) {
  59             this->rot_labels_data = DynMem(cells_size);
  60             this->rot_labels = cv::Mat(windows_size.height / int(cell_size), windows_size.width / int(cell_size),
  61                                        CV_32FC1, this->rot_labels_data.hostMem());
  62         }
  63
  64         this->data_features = DynMem(cells_size * num_of_feats);
  65         this->fw_all = cv::Mat((windows_size.height / int(cell_size)) * int(num_of_feats),
  66                                windows_size.width / int(cell_size), CV_32F, this->data_features.hostMem());
  67 #else
  68
  69         this->xf_sqr_norm = DynMem(num_of_scales * sizeof(float));
  70         this->yf_sqr_norm = DynMem(sizeof (float));
  71
  72         this->patch_feats.reserve(num_of_feats);
  73
  74         uint height = uint(windows_size.height) / cell_size;
  75 #ifdef FFTW
  76         uint width = (uint(windows_size.width) / cell_size) / 2 + 1;
  77 #else
  78         int width = windows_size.width / cell_size;
  79 #endif
  80
  81         this->ifft2_res = cv::Mat(int(height), windows_size.width / int(cell_size), CV_32FC(int(num_of_feats)));
  82         this->response = cv::Mat(int(height), windows_size.width / int(cell_size), CV_32FC(int(num_of_scales)));
  83
  84         this->zf = ComplexMat(height, width, num_of_feats, num_of_scales);
  85         this->kzf = ComplexMat(height, width, num_of_scales);
  86         this->kf = ComplexMat(height, width, num_of_scales);
  87 #ifdef FFTW
  88         this->in_all = cv::Mat((windows_size.height / int(cell_size)) * int(num_of_scales),
  89                                windows_size.width / int(cell_size), CV_32F);
  90         this->fw_all = cv::Mat((windows_size.height / int(cell_size)) * int(num_of_feats),
  91                                windows_size.width / int(cell_size), CV_32F);
  92 #else
  93         this->in_all = cv::Mat((windows_size.height / int(cell_size)), windows_size.width / int(cell_size), CV_32F);
  94 #endif
  95 #endif
  96 #if defined(FFTW) || defined(CUFFT)
  97         if (zero_index) {
  98             model_xf->create(uint(windows_size.height) / cell_size, (uint(windows_size.width) / cell_size) / 2 + 1,
  99                              num_of_feats);
 100             yf->create(uint(windows_size.height) / cell_size, (uint(windows_size.width) / cell_size) / 2 + 1, 1);
 101             // We use scale_vars[0] for updating the tracker, so we only allocate memory for  its xf only.
 102 #ifdef CUFFT
 103             this->xf.create(uint(windows_size.height) / cell_size, (uint(windows_size.width) / cell_size) / 2 + 1,
 104                             num_of_feats, this->stream);
 105 #else
 106             this->xf.create(uint(windows_size.height) / cell_size, (uint(windows_size.width) / cell_size) / 2 + 1,
 107                             num_of_feats);
 108 #endif
 109         } else if (num_of_scales > 1) {
 110             this->max_responses.reserve(uint(num_of_scales));
 111             this->max_locs.reserve(uint(num_of_scales));
 112             this->response_maps.reserve(uint(num_of_scales));
 113         }
 114 #else
 115         if (zero_index) {
 116             model_xf->create(windows_size.height / cell_size, windows_size.width / cell_size, num_of_feats);
 117             yf->create(windows_size.height / cell_size, windows_size.width / cell_size, 1);
 118             this->xf.create(windows_size.height / cell_size, windows_size.width / cell_size, num_of_feats);
 119         }
 120 #endif
 121     }
 122
 123     ~ThreadCtx()
 124     {
 125 #if defined(CUFFT) && (defined(ASYNC) || defined(OPENMP))
 126         CudaSafeCall(cudaStreamDestroy(this->stream));
 127 #endif
 128     }
 129
 130     DynMem xf_sqr_norm, yf_sqr_norm;
 131     std::vector<cv::Mat> patch_feats;
 132
 133     cv::Mat in_all, fw_all, ifft2_res, response;
 134     ComplexMat zf, kzf, kf, xyf, xf;
 135
 136     // CuFFT variables
 137     cv::Mat rot_labels;
 138     DynMem gauss_corr_res, rot_labels_data, data_features, data_f, data_i_features, data_i_1ch;
 139
 140     cudaStream_t stream = nullptr;
 141     ComplexMat model_alphaf, model_xf;
 142
 143     // Big batch variables
 144     cv::Point2i max_loc;
 145     double max_val, max_response;
 146
 147     std::vector<double> max_responses;
 148     std::vector<cv::Point2i> max_locs;
 149     std::vector<cv::Mat> response_maps;
 150     bool zero_index = false;
 151 };
 152
 153 #endif // SCALE_VARS_HPP