Merge rotation branch

[hercules2020/kcf.git] / src / dynmem.hpp

diff --git a/src/dynmem.hpp b/src/dynmem.hpp
index 395ff74118d80327d253fba1ff6df06ec3dd0548..f45609419b4f4883960e3b8496f90a64e037915f 100644 (file)
--- a/src/dynmem.hpp
+++ b/src/dynmem.hpp
@@ -9,7 +9,7 @@
 #if defined(CUFFT) || defined(CUFFTW)
 #include "cuda_runtime.h"
 #ifdef CUFFT
-#include "cuda/cuda_error_check.cuh"
+#include "cuda_error_check.hpp"
 #endif
 #endif
 
@@ -19,9 +19,10 @@ template <typename T> class DynMem_ {
 #ifdef CUFFT
     T *ptr_d = nullptr;
 #endif
-    size_t num_elem;
   public:
-    typedef T type;
+    typedef T value_type;
+    const size_t num_elem;
+
     DynMem_(size_t num_elem) : num_elem(num_elem)
     {
 #ifdef CUFFT
@@ -31,7 +32,12 @@ template <typename T> class DynMem_ {
         ptr_h = new T[num_elem];
 #endif
     }
-    DynMem_(DynMem_&& other) {
+    DynMem_(const DynMem_ &other) : DynMem_(other.num_elem)
+    {
+        memcpy(ptr_h, other.ptr_h, num_elem * sizeof(T));
+    }
+    DynMem_(DynMem_ &&other) : num_elem(other.num_elem)
+    {
         ptr_h = other.ptr_h;
         other.ptr_h = nullptr;
 #ifdef CUFFT
@@ -41,21 +47,22 @@ template <typename T> class DynMem_ {
     }
     ~DynMem_()
     {
-#ifdef CUFFT
-        CudaSafeCall(cudaFreeHost(ptr_h));
-#else
-        delete[] ptr_h;
-#endif
+        release();
     }
     T *hostMem() { return ptr_h; }
+    const T *hostMem() const { return ptr_h; }
 #ifdef CUFFT
     T *deviceMem() { return ptr_d; }
+    const T *deviceMem() const { return ptr_d; }
 #endif
     void operator=(DynMem_ &rhs) {
+        assert(num_elem == rhs.num_elem);
         memcpy(ptr_h, rhs.ptr_h, num_elem * sizeof(T));
     }
     void operator=(DynMem_ &&rhs)
     {
+        assert(num_elem == rhs.num_elem);
+        release();
         ptr_h = rhs.ptr_h;
         rhs.ptr_h = nullptr;
 #ifdef CUFFT
@@ -64,6 +71,15 @@ template <typename T> class DynMem_ {
 #endif
     }
     T operator[](uint i) const { return ptr_h[i]; }
+private:
+    void release()
+    {
+#ifdef CUFFT
+        CudaSafeCall(cudaFreeHost(ptr_h));
+#else
+        delete[] ptr_h;
+#endif
+    }
 };
 
 typedef DynMem_<float> DynMem;
@@ -119,6 +135,12 @@ public:
         assert(int(idx) < size[0]);
         return cv::Mat(size[1], size[2], cv::Mat::type(), ptr(idx));
     }
+    const cv::Mat plane(uint idx) const {
+        assert(dims == 3);
+        assert(int(idx) < size[0]);
+        return cv::Mat(size[1], size[2], cv::Mat::type(), const_cast<uchar*>(ptr(idx)));
+    }
+
 };
 
 class MatFeats : public Mat3d
@@ -144,6 +166,11 @@ public:
         assert(int(feature) < size[1]);
         return cv::Mat(size[2], size[3], cv::Mat::type(), ptr(scale, feature));
     }
+    cv::Mat scale(uint scale) {
+        assert(dims == 4);
+        assert(int(scale) < size[0]);
+        return cv::Mat(3, std::vector<int>({size[1], size[2], size[3]}).data(), cv::Mat::type(), ptr(scale));
+    }
 };
 
 #endif // DYNMEM_HPP