Added support for vector of gpuMatND

modules/core/include/opencv2/core/mat.hpp

@@ -288,7 +288,8 @@ public:
         STD_BOOL_VECTOR   =12 << KIND_SHIFT,
         STD_VECTOR_CUDA_GPU_MAT = 13 << KIND_SHIFT,
         STD_ARRAY_MAT     =15 << KIND_SHIFT,
-        CUDA_GPU_MATND    =16 << KIND_SHIFT
+        CUDA_GPU_MATND    =16 << KIND_SHIFT,
+        STD_VECTOR_CUDA_GPU_MAT_ND = 17 << KIND_SHIFT
     };
 
     _InputArray();
@@ -308,6 +309,7 @@ public:
     _InputArray(const cuda::GpuMat& d_mat);
     _InputArray(const std::vector<cuda::GpuMat>& d_mat_array);
     _InputArray(const cuda::GpuMatND& d_mat);
+    _InputArray(const std::vector<cuda::GpuMatND>& d_mat_array);
     _InputArray(const ogl::Buffer& buf);
     _InputArray(const cuda::HostMem& cuda_mem);
     template<typename _Tp> _InputArray(const cudev::GpuMat_<_Tp>& m);
@@ -326,6 +328,7 @@ public:
     void getMatVector(std::vector<Mat>& mv) const;
     void getUMatVector(std::vector<UMat>& umv) const;
     void getGpuMatVector(std::vector<cuda::GpuMat>& gpumv) const;
+    void getGpuMatNDVector(std::vector<cuda::GpuMatND>& gpumv) const;
     cuda::GpuMat getGpuMat() const;
     cuda::GpuMatND getGpuMatND() const;
     ogl::Buffer getOGlBuffer() const;
@@ -433,6 +436,7 @@ public:
     _OutputArray(cuda::GpuMat& d_mat);
     _OutputArray(std::vector<cuda::GpuMat>& d_mat);
     _OutputArray(cuda::GpuMatND& d_mat);
+    _OutputArray(std::vector<cuda::GpuMatND>& d_mat);
     _OutputArray(ogl::Buffer& buf);
     _OutputArray(cuda::HostMem& cuda_mem);
     template<typename _Tp> _OutputArray(cudev::GpuMat_<_Tp>& m);
@@ -452,6 +456,7 @@ public:
     _OutputArray(const cuda::GpuMat& d_mat);
     _OutputArray(const std::vector<cuda::GpuMat>& d_mat);
     _OutputArray(const cuda::GpuMatND& d_mat);
+    _OutputArray(const std::vector<cuda::GpuMatND>& d_mat);
     _OutputArray(const ogl::Buffer& buf);
     _OutputArray(const cuda::HostMem& cuda_mem);
     template<typename _Tp> _OutputArray(const cudev::GpuMat_<_Tp>& m);
@@ -479,6 +484,7 @@ public:
     UMat& getUMatRef(int i=-1) const;
     cuda::GpuMat& getGpuMatRef() const;
     std::vector<cuda::GpuMat>& getGpuMatVecRef() const;
+    std::vector<cuda::GpuMatND>& getGpuMatNDVecRef() const;
     std::vector<Mat>& getMatVecRef() const;
     std::vector<UMat>& getUMatVecRef() const;
     template<typename _Tp> std::vector<std::vector<_Tp> >& getVecVecRef() const;
@@ -524,6 +530,8 @@ public:
     _InputOutputArray(std::vector<Mat>& vec);
     _InputOutputArray(cuda::GpuMat& d_mat);
     _InputOutputArray(cuda::GpuMatND& d_mat);
+    _InputOutputArray(std::vector<cuda::GpuMat>& d_mat);
+    _InputOutputArray(std::vector<cuda::GpuMatND>& d_mat);
     _InputOutputArray(ogl::Buffer& buf);
     _InputOutputArray(cuda::HostMem& cuda_mem);
     template<typename _Tp> _InputOutputArray(cudev::GpuMat_<_Tp>& m);
@@ -542,6 +550,7 @@ public:
     _InputOutputArray(const cuda::GpuMat& d_mat);
     _InputOutputArray(const std::vector<cuda::GpuMat>& d_mat);
     _InputOutputArray(const cuda::GpuMatND& d_mat);
+    _InputOutputArray(const std::vector<cuda::GpuMatND>& d_mat);
     _InputOutputArray(const ogl::Buffer& buf);
     _InputOutputArray(const cuda::HostMem& cuda_mem);
     template<typename _Tp> _InputOutputArray(const cudev::GpuMat_<_Tp>& m);

modules/core/include/opencv2/core/mat.inl.hpp

@@ -219,6 +219,9 @@ inline _InputArray::_InputArray(const std::vector<cuda::GpuMat>& d_mat)
 inline _InputArray::_InputArray(const cuda::GpuMatND& d_mat)
 { init(+CUDA_GPU_MATND + ACCESS_READ, &d_mat); }
 
+inline _InputArray::_InputArray(const std::vector<cuda::GpuMatND>& d_mat)
+{ init(+STD_VECTOR_CUDA_GPU_MAT_ND + ACCESS_READ, &d_mat);}
+
 inline _InputArray::_InputArray(const ogl::Buffer& buf)
 { init(+OPENGL_BUFFER + ACCESS_READ, &buf); }
 
@@ -348,6 +351,9 @@ inline _OutputArray::_OutputArray(std::vector<cuda::GpuMat>& d_mat)
 inline _OutputArray::_OutputArray(cuda::GpuMatND& d_mat)
 { init(+CUDA_GPU_MATND + ACCESS_WRITE, &d_mat); }
 
+inline _OutputArray::_OutputArray(std::vector<cuda::GpuMatND>& d_mat)
+{ init(+STD_VECTOR_CUDA_GPU_MAT_ND + ACCESS_WRITE, &d_mat); }
+
 inline _OutputArray::_OutputArray(ogl::Buffer& buf)
 { init(+OPENGL_BUFFER + ACCESS_WRITE, &buf); }
 
@@ -372,6 +378,9 @@ inline _OutputArray::_OutputArray(const cuda::GpuMat& d_mat)
 inline _OutputArray::_OutputArray(const cuda::GpuMatND& d_mat)
 { init(+FIXED_TYPE + FIXED_SIZE + CUDA_GPU_MATND + ACCESS_WRITE, &d_mat); }
 
+inline _OutputArray::_OutputArray(const std::vector<cuda::GpuMatND>& d_mat)
+{ init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_CUDA_GPU_MAT_ND + ACCESS_WRITE, &d_mat); }
+
 inline _OutputArray::_OutputArray(const ogl::Buffer& buf)
 { init(FIXED_TYPE + FIXED_SIZE + OPENGL_BUFFER + ACCESS_WRITE, &buf); }
 
@@ -498,6 +507,12 @@ inline _InputOutputArray::_InputOutputArray(cuda::GpuMat& d_mat)
 inline _InputOutputArray::_InputOutputArray(cuda::GpuMatND& d_mat)
 { init(+CUDA_GPU_MATND + ACCESS_RW, &d_mat); }
 
+inline _InputOutputArray::_InputOutputArray(std::vector<cuda::GpuMat>& d_mat)
+{ init(+STD_VECTOR_CUDA_GPU_MAT + ACCESS_RW, &d_mat); }
+
+inline _InputOutputArray::_InputOutputArray(std::vector<cuda::GpuMatND>& d_mat)
+{ init(+STD_VECTOR_CUDA_GPU_MAT_ND + ACCESS_RW, &d_mat); }
+
 inline _InputOutputArray::_InputOutputArray(ogl::Buffer& buf)
 { init(+OPENGL_BUFFER + ACCESS_RW, &buf); }
 
@@ -528,6 +543,9 @@ template<> inline _InputOutputArray::_InputOutputArray(std::vector<cuda::GpuMat>
 inline _InputOutputArray::_InputOutputArray(const cuda::GpuMatND& d_mat)
 { init(+FIXED_TYPE + FIXED_SIZE + CUDA_GPU_MATND + ACCESS_RW, &d_mat); }
 
+inline _InputOutputArray::_InputOutputArray(const std::vector<cuda::GpuMatND>& d_mat)
+{ init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_CUDA_GPU_MAT_ND + ACCESS_RW, &d_mat);}
+
 inline _InputOutputArray::_InputOutputArray(const ogl::Buffer& buf)
 { init(FIXED_TYPE + FIXED_SIZE + OPENGL_BUFFER + ACCESS_RW, &buf); }
 

modules/core/src/matrix_wrap.cpp

@@ -366,6 +366,19 @@ void _InputArray::getGpuMatVector(std::vector<cuda::GpuMat>& gpumv) const
     CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)");
 #endif
 }
+void _InputArray::getGpuMatNDVector(std::vector<cuda::GpuMatND>& gpumv) const
+{
+#ifdef HAVE_CUDA
+    _InputArray::KindFlag k = kind();
+    if (k == STD_VECTOR_CUDA_GPU_MAT_ND)
+    {
+        gpumv = *(std::vector<cuda::GpuMatND>*)obj;
+    }
+#else
+    CV_UNUSED(gpumv);
+    CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)");
+#endif
+}
 cuda::GpuMatND _InputArray::getGpuMatND() const
 {
 #ifdef HAVE_CUDA
@@ -520,6 +533,24 @@ Size _InputArray::size(int i) const
 #endif
     }
 
+    if (k == STD_VECTOR_CUDA_GPU_MAT_ND)
+    {
+#ifdef HAVE_CUDA
+        const std::vector<cuda::GpuMatND>& vv = *(const std::vector<cuda::GpuMatND>*)obj;
+        if (i < 0)
+            return vv.empty() ? Size() : Size((int)vv.size(), 1);
+        CV_Assert(i < (int)vv.size());
+        const cuda::GpuMatND& m = vv[i];
+        if (m.dims == 0)
+            return Size();
+        if (m.dims == 1)
+            return Size(1, m.size[0]);
+        return Size(m.size[1], m.size[0]);
+#else
+        CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)");
+#endif
+    }
+
     if( k == STD_VECTOR_UMAT )
     {
         const std::vector<UMat>& vv = *(const std::vector<UMat>*)obj;
@@ -530,6 +561,24 @@ Size _InputArray::size(int i) const
         return vv[i].size();
     }
 
+    if (k == STD_VECTOR_CUDA_GPU_MAT_ND)
+    {
+#ifdef HAVE_CUDA
+        const std::vector<cuda::GpuMatND>& vv = *(const std::vector<cuda::GpuMatND>*)obj;
+        if (i < 0)
+            return vv.empty() ? Size() : Size((int)vv.size(), 1);
+        CV_Assert(i < (int)vv.size());
+        const cuda::GpuMatND& m = vv[i];
+        if (m.dims == 0)
+            return Size();
+        if (m.dims == 1)
+            return Size(1, m.size[0]);
+        return Size(m.size[1], m.size[0]);
+#else
+        CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)");
+#endif
+    }
+
     if( k == OPENGL_BUFFER )
     {
         CV_Assert( i < 0 );
@@ -1027,6 +1076,12 @@ bool _InputArray::empty() const
     if( k == CUDA_GPU_MATND )
         return ((const cuda::GpuMatND*)obj)->empty();
 
+    if (k == STD_VECTOR_CUDA_GPU_MAT_ND)
+    {
+        const std::vector<cuda::GpuMatND>& vv = *(const std::vector<cuda::GpuMatND>*)obj;
+        return vv.empty();
+    }
+
     if( k == CUDA_HOST_MEM )
         return ((const cuda::HostMem*)obj)->empty();
 
@@ -1117,6 +1172,13 @@ bool _InputArray::isSubmatrix(int i) const
         return ((const cuda::GpuMatND*)obj)->isSubmatrix();
     }
 
+    if (k == STD_VECTOR_CUDA_GPU_MAT_ND)
+    {
+        const std::vector<cuda::GpuMatND>& vv = *(const std::vector<cuda::GpuMatND>*)obj;
+        CV_Assert(i >= 0 && (size_t)i < vv.size());
+        return vv[i].isSubmatrix();
+    }
+
     CV_Error(cv::Error::StsNotImplemented, "");
 }
 
@@ -1235,10 +1297,19 @@ size_t _InputArray::step(int i) const
     if( k == CUDA_GPU_MATND )
     {
         const cuda::GpuMatND& _gpuMatND = *(const cuda::GpuMatND*)obj;
-        CV_Assert( i >= _gpuMatND.dims );
+        CV_Assert( i >= 0 && i < _gpuMatND.dims );
         return _gpuMatND.step[i];
     }
 
+    if (k == STD_VECTOR_CUDA_GPU_MAT_ND)
+    {
+        const std::vector<cuda::GpuMatND>& vv = *(const std::vector<cuda::GpuMatND>*)obj;
+        CV_Assert(i >= 0 && (size_t)i < vv.size());
+        const cuda::GpuMatND& _gpuMatND = vv[i];
+        CV_Assert( _gpuMatND.dims > 0 );
+        return _gpuMatND.step[0];
+    }
+
     CV_Error(Error::StsNotImplemented, "");
 }
 
@@ -2110,6 +2181,13 @@ cuda::GpuMatND& _OutputArray::getGpuMatNDRef() const
     return *(cuda::GpuMatND*)obj;
 }
 
+std::vector<cuda::GpuMatND>& _OutputArray::getGpuMatNDVecRef() const
+{
+    _InputArray::KindFlag k = kind();
+    CV_Assert(k == STD_VECTOR_CUDA_GPU_MAT_ND);
+    return *(std::vector<cuda::GpuMatND>*)obj;
+}
+
 ogl::Buffer& _OutputArray::getOGlBufferRef() const
 {
     _InputArray::KindFlag k = kind();