// This file is part of OpenCV project. // It is subject to the license terms in the LICENSE file found in the top-level directory // of this distribution and at http://opencv.org/license.html #include "precomp.hpp" #include "opencv2/core/mat.hpp" namespace cv { typedef Vec Vec5i; typedef Vec Vec7i; typedef Vec Vec9i; typedef Vec Vec10i; typedef Vec Vec11i; typedef Vec Vec12i; typedef Vec Vec13i; typedef Vec Vec14i; typedef Vec Vec15i; typedef Vec Vec16i; typedef Vec Vec32i; typedef Vec Vec64i; typedef Vec Vec128i; #undef STD_VECTOR_SWITCH #define STD_VECTOR_SWITCH(esz, func) \ switch( esz ) \ { \ case 1: func(uchar); \ case 2: func(Vec2b); \ case 3: func(Vec3b); \ case 4: func(int); \ case 6: func(Vec3s); \ case 8: func(Vec2i); \ case 12: func(Vec3i); \ case 16: func(Vec4i); \ case 20: func(Vec5i); \ case 24: func(Vec6i); \ case 28: func(Vec7i); \ case 32: func(Vec8i); \ case 36: func(Vec9i); \ case 40: func(Vec10i); \ case 44: func(Vec11i); \ case 48: func(Vec12i); \ case 52: func(Vec13i); \ case 56: func(Vec14i); \ case 60: func(Vec15i); \ case 64: func(Vec16i); \ case 128: func(Vec32i); \ case 256: func(Vec64i); \ case 512: func(Vec128i); \ default: \ CV_Error_(cv::Error::StsBadArg, ("Vectors of vectors with element size %d are not supported. Please, modify STD_VECTOR_SWITCH() macro\n", esz)); \ } /*************************************************************************************************\ Input/Output Array \*************************************************************************************************/ Mat _InputArray::getMat_(int i) const { _InputArray::KindFlag k = kind(); AccessFlag accessFlags = flags & ACCESS_MASK; if( k == MAT ) { const Mat* m = (const Mat*)obj; if( i < 0 ) return *m; return m->row(i); } if( k == UMAT ) { const UMat* m = (const UMat*)obj; if( i < 0 ) return m->getMat(accessFlags); return m->getMat(accessFlags).row(i); } if (k == MATX) { CV_Assert( i < 0 ); return Mat(sz, flags, obj); } if( k == STD_BOOL_VECTOR ) { CV_Assert( i < 0 ); int t = CV_8U; const std::vector& v = *(const std::vector*)obj; int j, n = (int)v.size(); if( n == 0 ) return Mat(); Mat m(1, &n, t); uchar* dst = m.data; for( j = 0; j < n; j++ ) dst[j] = (uchar)v[j]; return m; } if( k == NONE ) return Mat(); if( k == STD_VECTOR || k == STD_VECTOR_VECTOR ) { int t = CV_MAT_TYPE(flags); int esz = CV_ELEM_SIZE(t); #undef GET_MAT #define GET_MAT(T) \ { \ std::vector* v; \ if (k == STD_VECTOR_VECTOR) { \ std::vector >* vv = \ reinterpret_cast >*>(obj); \ CV_Assert(size_t(i) < vv->size()); \ v = &vv->at(i); \ } else { \ v = reinterpret_cast*>(obj); \ } \ int v_sz = int(v->size()); \ return v->empty() ? Mat() : Mat(1, &v_sz, t, v->data()); \ } STD_VECTOR_SWITCH(esz, GET_MAT) } if( k == STD_VECTOR_MAT ) { const std::vector& v = *(const std::vector*)obj; CV_Assert( 0 <= i && i < (int)v.size() ); return v[i]; } if( k == STD_ARRAY_MAT ) { const Mat* v = (const Mat*)obj; CV_Assert( 0 <= i && i < sz.height ); return v[i]; } if( k == STD_VECTOR_UMAT ) { const std::vector& v = *(const std::vector*)obj; CV_Assert( 0 <= i && i < (int)v.size() ); return v[i].getMat(accessFlags); } if( k == OPENGL_BUFFER ) { CV_Assert( i < 0 ); CV_Error(cv::Error::StsNotImplemented, "You should explicitly call mapHost/unmapHost methods for ogl::Buffer object"); } if( k == CUDA_GPU_MAT ) { CV_Assert( i < 0 ); CV_Error(cv::Error::StsNotImplemented, "You should explicitly call download method for cuda::GpuMat object"); } if( k == CUDA_GPU_MATND ) { CV_Assert( i < 0 ); CV_Error(cv::Error::StsNotImplemented, "You should explicitly call download method for cuda::GpuMatND object"); } if( k == CUDA_HOST_MEM ) { CV_Assert( i < 0 ); const cuda::HostMem* cuda_mem = (const cuda::HostMem*)obj; return cuda_mem->createMatHeader(); } CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } UMat _InputArray::getUMat(int i) const { _InputArray::KindFlag k = kind(); AccessFlag accessFlags = flags & ACCESS_MASK; if( k == UMAT ) { const UMat* m = (const UMat*)obj; if( i < 0 ) return *m; return m->row(i); } if( k == STD_VECTOR_UMAT ) { const std::vector& v = *(const std::vector*)obj; CV_Assert( 0 <= i && i < (int)v.size() ); return v[i]; } if( k == MAT ) { const Mat* m = (const Mat*)obj; if( i < 0 ) return m->getUMat(accessFlags); return m->row(i).getUMat(accessFlags); } return getMat(i).getUMat(accessFlags); } void _InputArray::getMatVector(std::vector& mv) const { _InputArray::KindFlag k = kind(); AccessFlag accessFlags = flags & ACCESS_MASK; if( k == MAT ) { const Mat& m = *(const Mat*)obj; int n = (int)m.size[0]; mv.resize(n); CV_Assert(m.dims >= 2); for( int i = 0; i < n; i++ ) mv[i] = m.dims <= 2 ? Mat(1, m.cols, m.type(), (void*)m.ptr(i)) : Mat(m.dims-1, &m.size[1], m.type(), (void*)m.ptr(i), &m.step[1]); return; } if (k == MATX) { size_t n = sz.height, esz = CV_ELEM_SIZE(flags); mv.resize(n); for( size_t i = 0; i < n; i++ ) mv[i] = Mat(1, sz.width, CV_MAT_TYPE(flags), (uchar*)obj + esz*sz.width*i); return; } if( k == STD_VECTOR ) { const std::vector& v = *(const std::vector*)obj; size_t n = total(), esz = CV_ELEM_SIZE(flags); int t = CV_MAT_DEPTH(flags), cn = CV_MAT_CN(flags); mv.resize(n); for( size_t i = 0; i < n; i++ ) mv[i] = Mat(1, cn, t, (void*)(v.data() + esz*i)); return; } if( k == NONE ) { mv.clear(); return; } if( k == STD_VECTOR_VECTOR ) { int typ = CV_MAT_TYPE(flags); int esz = CV_ELEM_SIZE(typ); #undef GET_VEC_VEC_MAT_VEC #define GET_VEC_VEC_MAT_VEC(T) \ { \ const std::vector >* vv = (const std::vector >*)obj; \ size_t n = vv->size(); \ mv.resize(n); \ for (size_t i = 0; i < n; i++) { \ const std::vector& vi = vv->at(i); \ CV_Assert(vi.size() <= (size_t)INT_MAX); \ int ni = (int)vi.size(); \ mv[i] = ni > 0 ? Mat(1, &ni, typ, (void*)vi.data()) : Mat(); \ } \ } \ break STD_VECTOR_SWITCH(esz, GET_VEC_VEC_MAT_VEC) return; } if( k == STD_VECTOR_MAT ) { const std::vector& v = *(const std::vector*)obj; size_t n = v.size(); mv.resize(n); for( size_t i = 0; i < n; i++ ) mv[i] = v[i]; return; } if( k == STD_ARRAY_MAT ) { const Mat* v = (const Mat*)obj; size_t n = sz.height; mv.resize(n); for( size_t i = 0; i < n; i++ ) mv[i] = v[i]; return; } if( k == STD_VECTOR_UMAT ) { const std::vector& v = *(const std::vector*)obj; size_t n = v.size(); mv.resize(n); for( size_t i = 0; i < n; i++ ) mv[i] = v[i].getMat(accessFlags); return; } CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } void _InputArray::getUMatVector(std::vector& umv) const { _InputArray::KindFlag k = kind(); AccessFlag accessFlags = flags & ACCESS_MASK; if( k == NONE ) { umv.clear(); return; } if( k == STD_VECTOR_MAT ) { const std::vector& v = *(const std::vector*)obj; size_t n = v.size(); umv.resize(n); for( size_t i = 0; i < n; i++ ) umv[i] = v[i].getUMat(accessFlags); return; } if( k == STD_ARRAY_MAT ) { const Mat* v = (const Mat*)obj; size_t n = sz.height; umv.resize(n); for( size_t i = 0; i < n; i++ ) umv[i] = v[i].getUMat(accessFlags); return; } if( k == STD_VECTOR_UMAT ) { const std::vector& v = *(const std::vector*)obj; size_t n = v.size(); umv.resize(n); for( size_t i = 0; i < n; i++ ) umv[i] = v[i]; return; } if( k == UMAT ) { UMat& v = *(UMat*)obj; umv.resize(1); umv[0] = v; return; } if( k == MAT ) { Mat& v = *(Mat*)obj; umv.resize(1); umv[0] = v.getUMat(accessFlags); return; } CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } cuda::GpuMat _InputArray::getGpuMat() const { #ifdef HAVE_CUDA _InputArray::KindFlag k = kind(); if (k == CUDA_GPU_MAT) { const cuda::GpuMat* d_mat = (const cuda::GpuMat*)obj; return *d_mat; } if (k == CUDA_HOST_MEM) { const cuda::HostMem* cuda_mem = (const cuda::HostMem*)obj; return cuda_mem->createGpuMatHeader(); } if (k == OPENGL_BUFFER) { CV_Error(cv::Error::StsNotImplemented, "You should explicitly call mapDevice/unmapDevice methods for ogl::Buffer object"); } if (k == NONE) return cuda::GpuMat(); CV_Error(cv::Error::StsNotImplemented, "getGpuMat is available only for cuda::GpuMat and cuda::HostMem"); #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } void _InputArray::getGpuMatVector(std::vector& gpumv) const { #ifdef HAVE_CUDA _InputArray::KindFlag k = kind(); if (k == STD_VECTOR_CUDA_GPU_MAT) { gpumv = *(std::vector*)obj; } #else CV_UNUSED(gpumv); CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } void _InputArray::getGpuMatNDVector(std::vector& gpumv) const { #ifdef HAVE_CUDA _InputArray::KindFlag k = kind(); if (k == STD_VECTOR_CUDA_GPU_MAT_ND) { gpumv = *(std::vector*)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 _InputArray::KindFlag k = kind(); if (k == CUDA_GPU_MATND) { const cuda::GpuMatND* d_mat = (const cuda::GpuMatND*)obj; return *d_mat; } CV_Error(cv::Error::StsNotImplemented, "getGpuMatND is available only for cuda::GpuMatND"); #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } ogl::Buffer _InputArray::getOGlBuffer() const { _InputArray::KindFlag k = kind(); CV_Assert(k == OPENGL_BUFFER); const ogl::Buffer* gl_buf = (const ogl::Buffer*)obj; return *gl_buf; } _InputArray::KindFlag _InputArray::kind() const { KindFlag k = flags & KIND_MASK; #if CV_VERSION_MAJOR < 5 CV_DbgAssert(k != EXPR); CV_DbgAssert(k != STD_ARRAY); #endif return k; } int _InputArray::rows(int i) const { #ifdef HAVE_CUDA _InputArray::KindFlag k = kind(); if (k == CUDA_GPU_MATND) { const cuda::GpuMatND& _gpuMatND = *(const cuda::GpuMatND*)obj; return (_gpuMatND.dims < 1) ? 0 : _gpuMatND.size[0]; } #endif return size(i).height; } int _InputArray::cols(int i) const { #ifdef HAVE_CUDA _InputArray::KindFlag k = kind(); if (k == CUDA_GPU_MATND) { const cuda::GpuMatND& _gpuMatND = *(const cuda::GpuMatND*)obj; return (_gpuMatND.dims < 2) ? 0 : _gpuMatND.size[1]; } #endif return size(i).width; } Size _InputArray::size(int i) const { _InputArray::KindFlag k = kind(); if( k == MAT ) { CV_Assert( i < 0 ); const Mat* m = (const Mat*)obj; CV_Assert(m->dims <= 2); return Size(m->cols, m->rows); } if( k == UMAT ) { CV_Assert( i < 0 ); const UMat* m = (const UMat*)obj; CV_Assert(m->dims <= 2); return Size(m->cols, m->rows); } if (k == MATX) { CV_Assert( i < 0 ); return sz; } if( k == NONE ) return Size(); if( k == STD_VECTOR || k == STD_VECTOR_VECTOR || k == STD_BOOL_VECTOR ) { size_t n = total(i); CV_Assert(n <= (size_t)INT_MAX); return Size((int)n, 1); } if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; if( i < 0 ) return vv.empty() ? Size() : Size((int)vv.size(), 1); CV_Assert( i < (int)vv.size() ); return vv[i].size(); } if( k == STD_ARRAY_MAT ) { const Mat* vv = (const Mat*)obj; if( i < 0 ) return sz.height==0 ? Size() : Size(sz.height, 1); CV_Assert( i < sz.height ); return vv[i].size(); } if (k == STD_VECTOR_CUDA_GPU_MAT) { #ifdef HAVE_CUDA const std::vector& vv = *(const std::vector*)obj; if (i < 0) return vv.empty() ? Size() : Size((int)vv.size(), 1); CV_Assert(i < (int)vv.size()); return vv[i].size(); #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if (k == STD_VECTOR_CUDA_GPU_MAT_ND) { #ifdef HAVE_CUDA const std::vector& vv = *(const std::vector*)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& vv = *(const std::vector*)obj; if( i < 0 ) return vv.empty() ? Size() : Size((int)vv.size(), 1); CV_Assert( i < (int)vv.size() ); return vv[i].size(); } if (k == STD_VECTOR_CUDA_GPU_MAT_ND) { #ifdef HAVE_CUDA const std::vector& vv = *(const std::vector*)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 ); const ogl::Buffer* buf = (const ogl::Buffer*)obj; return buf->size(); } if( k == CUDA_GPU_MAT ) { CV_Assert( i < 0 ); const cuda::GpuMat* d_mat = (const cuda::GpuMat*)obj; return d_mat->size(); } if( k == CUDA_HOST_MEM ) { CV_Assert( i < 0 ); const cuda::HostMem* cuda_mem = (const cuda::HostMem*)obj; return cuda_mem->size(); } CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } int _InputArray::sizend(int* arrsz, int i) const { int j, d = 0; _InputArray::KindFlag k = kind(); if( k == NONE ) ; else if( k == MAT ) { CV_Assert( i < 0 ); const Mat& m = *(const Mat*)obj; d = m.dims; if(arrsz) for(j = 0; j < d; j++) arrsz[j] = m.size.p[j]; } else if( k == UMAT ) { CV_Assert( i < 0 ); const UMat& m = *(const UMat*)obj; d = m.dims; if(arrsz) for(j = 0; j < d; j++) arrsz[j] = m.size.p[j]; } else if( k == STD_VECTOR_MAT && i >= 0 ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert( i < (int)vv.size() ); const Mat& m = vv[i]; d = m.dims; if(arrsz) for(j = 0; j < d; j++) arrsz[j] = m.size.p[j]; } else if( k == STD_ARRAY_MAT && i >= 0 ) { const Mat* vv = (const Mat*)obj; CV_Assert( i < sz.height ); const Mat& m = vv[i]; d = m.dims; if(arrsz) for(j = 0; j < d; j++) arrsz[j] = m.size.p[j]; } else if( k == STD_VECTOR_UMAT && i >= 0 ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert( i < (int)vv.size() ); const UMat& m = vv[i]; d = m.dims; if(arrsz) for(j = 0; j < d; j++) arrsz[j] = m.size.p[j]; } else if (((k == STD_VECTOR || k == STD_BOOL_VECTOR || k == STD_VECTOR_VECTOR) && i < 0) || (k == STD_VECTOR_VECTOR && i >= 0)) { size_t n = total(i); d = 1; if(arrsz) { arrsz[0] = int(n); } } else { CV_CheckLE(dims(i), 2, "Not supported"); Size sz2d = size(i); d = 2; if(arrsz) { arrsz[0] = sz2d.height; arrsz[1] = sz2d.width; } } return d; } bool _InputArray::empty(int i) const { _InputArray::KindFlag k = kind(); if (i >= 0) { if (k == STD_VECTOR_MAT) { auto mv = reinterpret_cast*>(obj); CV_Assert((size_t)i < mv->size()); return mv->at(i).empty(); } else if (k == STD_VECTOR_MAT) { auto umv = reinterpret_cast*>(obj); CV_Assert((size_t)i < umv->size()); return umv->at(i).empty(); } else if (k == STD_VECTOR || k == STD_BOOL_VECTOR || k == STD_VECTOR_VECTOR) { size_t n = total(i); return n == 0; } else { CV_Error(Error::StsNotImplemented, ""); } } return empty(); } MatShape _InputArray::shape(int i) const { _InputArray::KindFlag k = kind(); MatShape shape; if( k == NONE ) ; else if( k == MAT ) { CV_Assert( i < 0 ); const Mat& m = *(const Mat*)obj; shape = m.size; } else if( k == UMAT ) { CV_Assert( i < 0 ); const UMat& m = *(const UMat*)obj; shape = m.size; } else if( k == STD_VECTOR_MAT && i >= 0 ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert( (size_t)i < vv.size() ); const Mat& m = vv[i]; shape = m.size; } else if( k == STD_ARRAY_MAT && i >= 0 ) { const Mat* vv = (const Mat*)obj; CV_Assert( i < sz.height ); const Mat& m = vv[i]; shape = m.size; } else if( k == STD_VECTOR_UMAT && i >= 0 ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert( (size_t)i < vv.size() ); const UMat& m = vv[i]; shape = m.size; } else { int sizes[CV_MAX_DIM]; int dims = sizend(sizes, i); shape = MatShape(dims, sizes); } return shape; } bool _InputArray::sameSize(const _InputArray& arr) const { _InputArray::KindFlag k1 = kind(), k2 = arr.kind(); Size sz1; if( k1 == MAT ) { const Mat* m = ((const Mat*)obj); if( k2 == MAT ) return m->size == ((const Mat*)arr.obj)->size; if( k2 == UMAT ) return m->size == ((const UMat*)arr.obj)->size; if( m->dims > 2 ) return false; sz1 = m->size(); } else if( k1 == UMAT ) { const UMat* m = ((const UMat*)obj); if( k2 == MAT ) return m->size == ((const Mat*)arr.obj)->size; if( k2 == UMAT ) return m->size == ((const UMat*)arr.obj)->size; if( m->dims > 2 ) return false; sz1 = m->size(); } else if ( (k1 == CUDA_GPU_MATND) && (k2 == CUDA_GPU_MATND)) { return ((const cuda::GpuMatND*)obj)->size == ((const cuda::GpuMatND*)arr.obj)->size; } else sz1 = size(); if( arr.dims() > 2 ) return false; return sz1 == arr.size(); } int _InputArray::dims(int i) const { _InputArray::KindFlag k = kind(); if( k == MAT ) { CV_Assert( i < 0 ); return ((const Mat*)obj)->dims; } if( k == UMAT ) { CV_Assert( i < 0 ); return ((const UMat*)obj)->dims; } if (k == MATX) { CV_Assert( i < 0 ); return 2; } if( k == STD_VECTOR || k == STD_BOOL_VECTOR ) { CV_Assert( i < 0 ); return 1; } if( k == NONE ) return 0; if( k == STD_VECTOR_VECTOR ) { if( i < 0 ) return 1; CV_Assert( size_t(i) < total() ); return 1; } if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; if( i < 0 ) return 1; CV_Assert( i < (int)vv.size() ); return vv[i].dims; } if( k == STD_ARRAY_MAT ) { const Mat* vv = (const Mat*)obj; if( i < 0 ) return 1; CV_Assert( i < sz.height ); return vv[i].dims; } if( k == STD_VECTOR_UMAT ) { const std::vector& vv = *(const std::vector*)obj; if( i < 0 ) return 1; CV_Assert( i < (int)vv.size() ); return vv[i].dims; } if( k == OPENGL_BUFFER ) { CV_Assert( i < 0 ); return 2; } if( k == CUDA_GPU_MAT ) { CV_Assert( i < 0 ); return 2; } if( k == CUDA_GPU_MATND ) { CV_Assert( i < 0 ); return ((const cuda::GpuMatND*)obj)->dims; } if( k == CUDA_HOST_MEM ) { CV_Assert( i < 0 ); return 2; } CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } size_t _InputArray::total(int i) const { _InputArray::KindFlag k = kind(); if( k == MAT ) { CV_Assert( i < 0 ); return ((const Mat*)obj)->total(); } if( k == UMAT ) { CV_Assert( i < 0 ); return ((const UMat*)obj)->total(); } if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; if( i < 0 ) return vv.size(); CV_Assert( i < (int)vv.size() ); return vv[i].total(); } if( k == STD_ARRAY_MAT ) { const Mat* vv = (const Mat*)obj; if( i < 0 ) return sz.height; CV_Assert( i < sz.height ); return vv[i].total(); } if( k == STD_VECTOR_UMAT ) { const std::vector& vv = *(const std::vector*)obj; if( i < 0 ) return vv.size(); CV_Assert( i < (int)vv.size() ); return vv[i].total(); } if( k == CUDA_GPU_MATND ) { CV_Assert( i < 0 ); size_t res = 0; const cuda::GpuMatND& _gpuMatND = *((const cuda::GpuMatND*)obj); if (_gpuMatND.dims > 0) { res = 1; for(int d = 0 ; d<_gpuMatND.dims ; ++d) res *= _gpuMatND.size[d]; return res; } } if (k == STD_VECTOR || k == STD_VECTOR_VECTOR) { CV_Assert(i < 0 || k == STD_VECTOR_VECTOR); int esz = CV_ELEM_SIZE(flags); #undef GET_VEC_SIZE #define GET_VEC_SIZE(T) \ if (k == STD_VECTOR_VECTOR) { \ const std::vector >* vv = (const std::vector >*)obj; \ size_t n = vv->size(); \ if (i < 0) \ return n; \ CV_Assert((size_t)i < n); \ return vv->at(i).size(); \ } else \ return ((const std::vector*)obj)->size() STD_VECTOR_SWITCH(esz, GET_VEC_SIZE) } return size(i).area(); } int _InputArray::type(int i) const { _InputArray::KindFlag k = kind(); if( k == MAT ) return ((const Mat*)obj)->type(); if( k == UMAT ) return ((const UMat*)obj)->type(); if( k == MATX || k == STD_VECTOR || k == STD_VECTOR_VECTOR || k == STD_BOOL_VECTOR ) return CV_MAT_TYPE(flags); if( k == NONE ) return -1; if( k == STD_VECTOR_UMAT ) { const std::vector& vv = *(const std::vector*)obj; if( vv.empty() ) { CV_Assert((flags & FIXED_TYPE) != 0); return CV_MAT_TYPE(flags); } CV_Assert( i < (int)vv.size() ); return vv[i >= 0 ? i : 0].type(); } if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; if( vv.empty() ) { CV_Assert((flags & FIXED_TYPE) != 0); return CV_MAT_TYPE(flags); } CV_Assert( i < (int)vv.size() ); return vv[i >= 0 ? i : 0].type(); } if( k == STD_ARRAY_MAT ) { const Mat* vv = (const Mat*)obj; if( sz.height == 0 ) { CV_Assert((flags & FIXED_TYPE) != 0); return CV_MAT_TYPE(flags); } CV_Assert( i < sz.height ); return vv[i >= 0 ? i : 0].type(); } if (k == STD_VECTOR_CUDA_GPU_MAT) { #ifdef HAVE_CUDA const std::vector& vv = *(const std::vector*)obj; if (vv.empty()) { CV_Assert((flags & FIXED_TYPE) != 0); return CV_MAT_TYPE(flags); } CV_Assert(i < (int)vv.size()); return vv[i >= 0 ? i : 0].type(); #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if (k == STD_VECTOR_CUDA_GPU_MAT_ND) { #ifdef HAVE_CUDA const std::vector& vv = *(const std::vector*)obj; if (vv.empty()) { CV_Assert((flags & FIXED_TYPE) != 0); return CV_MAT_TYPE(flags); } CV_Assert(i < (int)vv.size()); return vv[i >= 0 ? i : 0].type(); #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if( k == OPENGL_BUFFER ) return ((const ogl::Buffer*)obj)->type(); if( k == CUDA_GPU_MAT ) return ((const cuda::GpuMat*)obj)->type(); if( k == CUDA_GPU_MATND ) return ((const cuda::GpuMatND*)obj)->type(); if( k == CUDA_HOST_MEM ) return ((const cuda::HostMem*)obj)->type(); CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } int _InputArray::depth(int i) const { return CV_MAT_DEPTH(type(i)); } int _InputArray::channels(int i) const { return CV_MAT_CN(type(i)); } bool _InputArray::empty() const { _InputArray::KindFlag k = kind(); if( k == MAT ) return ((const Mat*)obj)->empty(); if( k == UMAT ) return ((const UMat*)obj)->empty(); if (k == MATX) return false; if( k == STD_VECTOR || k == STD_BOOL_VECTOR || k == STD_VECTOR_VECTOR ) { size_t n = total(-1); return n == 0; } if( k == NONE ) return true; if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; return vv.empty(); } if( k == STD_ARRAY_MAT ) { return sz.height == 0; } if( k == STD_VECTOR_UMAT ) { const std::vector& vv = *(const std::vector*)obj; return vv.empty(); } if( k == OPENGL_BUFFER ) return ((const ogl::Buffer*)obj)->empty(); if( k == CUDA_GPU_MAT ) return ((const cuda::GpuMat*)obj)->empty(); if (k == STD_VECTOR_CUDA_GPU_MAT) { const std::vector& vv = *(const std::vector*)obj; return vv.empty(); } if( k == CUDA_GPU_MATND ) return ((const cuda::GpuMatND*)obj)->empty(); if (k == STD_VECTOR_CUDA_GPU_MAT_ND) { const std::vector& vv = *(const std::vector*)obj; return vv.empty(); } if( k == CUDA_HOST_MEM ) return ((const cuda::HostMem*)obj)->empty(); CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } bool _InputArray::isContinuous(int i) const { _InputArray::KindFlag k = kind(); if( k == MAT ) return i < 0 ? ((const Mat*)obj)->isContinuous() : true; if( k == UMAT ) return i < 0 ? ((const UMat*)obj)->isContinuous() : true; if( k == MATX || k == STD_VECTOR || k == NONE || k == STD_VECTOR_VECTOR || k == STD_BOOL_VECTOR ) return true; if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return vv[i].isContinuous(); } if( k == STD_ARRAY_MAT ) { const Mat* vv = (const Mat*)obj; CV_Assert(i >= 0 && i < sz.height); return vv[i].isContinuous(); } if( k == STD_VECTOR_UMAT ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return vv[i].isContinuous(); } if( k == CUDA_GPU_MAT ) return i < 0 ? ((const cuda::GpuMat*)obj)->isContinuous() : true; if( k == CUDA_GPU_MATND ) return i < 0 ? ((const cuda::GpuMatND*)obj)->isContinuous() : true; CV_Error(cv::Error::StsNotImplemented, "Unknown/unsupported array type"); } bool _InputArray::isSubmatrix(int i) const { _InputArray::KindFlag k = kind(); if( k == MAT ) return i < 0 ? ((const Mat*)obj)->isSubmatrix() : false; if( k == UMAT ) return i < 0 ? ((const UMat*)obj)->isSubmatrix() : false; if( k == MATX || k == STD_VECTOR || k == NONE || k == STD_VECTOR_VECTOR || k == STD_BOOL_VECTOR ) return false; if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return vv[i].isSubmatrix(); } if( k == STD_ARRAY_MAT ) { const Mat* vv = (const Mat*)obj; CV_Assert(i >= 0 && i < sz.height); return vv[i].isSubmatrix(); } if( k == STD_VECTOR_UMAT ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return vv[i].isSubmatrix(); } if( k == CUDA_GPU_MATND ) { return ((const cuda::GpuMatND*)obj)->isSubmatrix(); } if (k == STD_VECTOR_CUDA_GPU_MAT_ND) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return vv[i].isSubmatrix(); } CV_Error(cv::Error::StsNotImplemented, ""); } size_t _InputArray::offset(int i) const { _InputArray::KindFlag k = kind(); if( k == MAT ) { CV_Assert( i < 0 ); const Mat * const m = ((const Mat*)obj); return (size_t)(m->ptr() - m->datastart); } if( k == UMAT ) { CV_Assert( i < 0 ); return ((const UMat*)obj)->offset; } if( k == MATX || k == STD_VECTOR || k == NONE || k == STD_VECTOR_VECTOR || k == STD_BOOL_VECTOR ) return 0; if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert( i >= 0 && i < (int)vv.size() ); return (size_t)(vv[i].ptr() - vv[i].datastart); } if( k == STD_ARRAY_MAT ) { const Mat* vv = (const Mat*)obj; CV_Assert( i >= 0 && i < sz.height ); return (size_t)(vv[i].ptr() - vv[i].datastart); } if( k == STD_VECTOR_UMAT ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return vv[i].offset; } if( k == CUDA_GPU_MAT ) { CV_Assert( i < 0 ); const cuda::GpuMat * const m = ((const cuda::GpuMat*)obj); return (size_t)(m->data - m->datastart); } if (k == STD_VECTOR_CUDA_GPU_MAT) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return (size_t)(vv[i].data - vv[i].datastart); } CV_Error(Error::StsNotImplemented, ""); } size_t _InputArray::step(int i) const { _InputArray::KindFlag k = kind(); if( k == MAT ) { CV_Assert( i < 0 ); return ((const Mat*)obj)->step; } if( k == UMAT ) { CV_Assert( i < 0 ); return ((const UMat*)obj)->step; } if( k == MATX || k == STD_VECTOR || k == NONE || k == STD_VECTOR_VECTOR || k == STD_BOOL_VECTOR ) return 0; if( k == STD_VECTOR_MAT ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert( i >= 0 && i < (int)vv.size() ); return vv[i].step; } if( k == STD_ARRAY_MAT ) { const Mat* vv = (const Mat*)obj; CV_Assert( i >= 0 && i < sz.height ); return vv[i].step; } if( k == STD_VECTOR_UMAT ) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return vv[i].step; } if( k == CUDA_GPU_MAT ) { CV_Assert( i < 0 ); return ((const cuda::GpuMat*)obj)->step; } if (k == STD_VECTOR_CUDA_GPU_MAT) { const std::vector& vv = *(const std::vector*)obj; CV_Assert(i >= 0 && (size_t)i < vv.size()); return vv[i].step; } if( k == CUDA_GPU_MATND ) { const cuda::GpuMatND& _gpuMatND = *(const cuda::GpuMatND*)obj; CV_Assert( i >= 0 && i < _gpuMatND.dims ); return _gpuMatND.step[i]; } if (k == STD_VECTOR_CUDA_GPU_MAT_ND) { const std::vector& vv = *(const std::vector*)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, ""); } void _InputArray::copyTo(const _OutputArray& arr) const { _InputArray::KindFlag k = kind(); if( k == NONE ) arr.release(); else if( k == MAT || k == MATX || k == STD_VECTOR || k == STD_BOOL_VECTOR ) { Mat m = getMat(); m.copyTo(arr); } else if( k == UMAT ) ((UMat*)obj)->copyTo(arr); #ifdef HAVE_CUDA else if (k == CUDA_GPU_MAT) ((cuda::GpuMat*)obj)->copyTo(arr); #endif else CV_Error(Error::StsNotImplemented, ""); } void _InputArray::copyTo(const _OutputArray& arr, const _InputArray & mask) const { _InputArray::KindFlag k = kind(); if( k == NONE ) arr.release(); else if( k == MAT || k == MATX || k == STD_VECTOR || k == STD_BOOL_VECTOR ) { Mat m = getMat(); m.copyTo(arr, mask); } else if( k == UMAT ) ((UMat*)obj)->copyTo(arr, mask); #ifdef HAVE_CUDA else if (k == CUDA_GPU_MAT) ((cuda::GpuMat*)obj)->copyTo(arr, mask); #endif else CV_Error(Error::StsNotImplemented, ""); } bool _OutputArray::fixedSize() const { return (flags & FIXED_SIZE) == FIXED_SIZE; } bool _OutputArray::fixedType() const { return (flags & FIXED_TYPE) == FIXED_TYPE; } void _OutputArray::create(Size _sz, int mtype, int i, bool allowTransposed, _OutputArray::DepthMask fixedDepthMask) const { _InputArray::KindFlag k = kind(); if( k == MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((Mat*)obj)->size.operator()() == _sz); CV_Assert(!fixedType() || ((Mat*)obj)->type() == mtype); ((Mat*)obj)->create(_sz, mtype); return; } if( k == UMAT && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((UMat*)obj)->size.operator()() == _sz); CV_Assert(!fixedType() || ((UMat*)obj)->type() == mtype); ((UMat*)obj)->create(_sz, mtype); return; } if( k == CUDA_GPU_MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((cuda::GpuMat*)obj)->size() == _sz); CV_Assert(!fixedType() || ((cuda::GpuMat*)obj)->type() == mtype); #ifdef HAVE_CUDA ((cuda::GpuMat*)obj)->create(_sz, mtype); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if( k == CUDA_GPU_MATND && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((((cuda::GpuMatND*)obj)->dims == 2) && (((cuda::GpuMatND*)obj)->size[0] == _sz.height) && (((cuda::GpuMatND*)obj)->size[1] == _sz.width))); CV_Assert(!fixedType() || ((cuda::GpuMatND*)obj)->type() == mtype); #ifdef HAVE_CUDA cuda::GpuMatND::SizeArray sizes({_sz.height, _sz.width}); ((cuda::GpuMatND*)obj)->create(sizes, mtype); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((ogl::Buffer*)obj)->size() == _sz); CV_Assert(!fixedType() || ((ogl::Buffer*)obj)->type() == mtype); #ifdef HAVE_OPENGL ((ogl::Buffer*)obj)->create(_sz, mtype); return; #else CV_Error(Error::StsNotImplemented, "OpenGL support is not enabled in this OpenCV build (missing HAVE_OPENGL)"); #endif } if( k == CUDA_HOST_MEM && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((cuda::HostMem*)obj)->size() == _sz); CV_Assert(!fixedType() || ((cuda::HostMem*)obj)->type() == mtype); #ifdef HAVE_CUDA ((cuda::HostMem*)obj)->create(_sz, mtype); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } int sizes[] = {_sz.height, _sz.width}; create(2, sizes, mtype, i, allowTransposed, fixedDepthMask); } void _OutputArray::create(int _rows, int _cols, int mtype, int i, bool allowTransposed, _OutputArray::DepthMask fixedDepthMask) const { _InputArray::KindFlag k = kind(); if( k == MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((Mat*)obj)->size.operator()() == Size(_cols, _rows)); CV_Assert(!fixedType() || ((Mat*)obj)->type() == mtype); ((Mat*)obj)->create(_rows, _cols, mtype); return; } if( k == UMAT && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((UMat*)obj)->size.operator()() == Size(_cols, _rows)); CV_Assert(!fixedType() || ((UMat*)obj)->type() == mtype); ((UMat*)obj)->create(_rows, _cols, mtype); return; } if( k == CUDA_GPU_MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((cuda::GpuMat*)obj)->size() == Size(_cols, _rows)); CV_Assert(!fixedType() || ((cuda::GpuMat*)obj)->type() == mtype); #ifdef HAVE_CUDA ((cuda::GpuMat*)obj)->create(_rows, _cols, mtype); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if( k == CUDA_GPU_MATND && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((((cuda::GpuMatND*)obj)->dims == 2) && (((cuda::GpuMatND*)obj)->size[0] == _rows) && (((cuda::GpuMatND*)obj)->size[1] == _cols))); CV_Assert(!fixedType() || ((cuda::GpuMatND*)obj)->type() == mtype); #ifdef HAVE_CUDA cuda::GpuMatND::SizeArray sizes({_rows, _cols}); ((cuda::GpuMatND*)obj)->create(sizes, mtype); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((ogl::Buffer*)obj)->size() == Size(_cols, _rows)); CV_Assert(!fixedType() || ((ogl::Buffer*)obj)->type() == mtype); #ifdef HAVE_OPENGL ((ogl::Buffer*)obj)->create(_rows, _cols, mtype); return; #else CV_Error(Error::StsNotImplemented, "OpenGL support is not enabled in this OpenCV build (missing HAVE_OPENGL)"); #endif } if( k == CUDA_HOST_MEM && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { CV_Assert(!fixedSize() || ((cuda::HostMem*)obj)->size() == Size(_cols, _rows)); CV_Assert(!fixedType() || ((cuda::HostMem*)obj)->type() == mtype); #ifdef HAVE_CUDA ((cuda::HostMem*)obj)->create(_rows, _cols, mtype); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } int sizes[] = {_rows, _cols}; create(2, sizes, mtype, i, allowTransposed, fixedDepthMask); } void _OutputArray::create(int d, const int* sizes, int mtype, int i, bool allowTransposed, _OutputArray::DepthMask fixedDepthMask) const { int size0 = d > 0 ? sizes[0] : 1, size1 = d > 1 ? sizes[1] : 1; _InputArray::KindFlag k = kind(); mtype = CV_MAT_TYPE(mtype); if( k == MAT ) { CV_Assert( i < 0 ); Mat& m = *(Mat*)obj; CV_Assert(!(m.empty() && fixedType() && fixedSize()) && "Can't reallocate empty Mat with locked layout (probably due to misused 'const' modifier)"); if (!m.empty() && d <= 2 && m.dims <= 2 && m.type() == mtype && ((m.rows == size0 && m.cols == size1) || (allowTransposed && m.rows == size1 && m.cols == size0 && m.isContinuous()))) { return; } if(fixedType()) { if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_DEPTH(flags)) & fixedDepthMask) != 0 ) mtype = m.type(); else CV_CheckTypeEQ(m.type(), CV_MAT_TYPE(mtype), "Can't reallocate Mat with locked type (probably due to misused 'const' modifier)"); } if(fixedSize()) { CV_CheckEQ(m.dims, d, "Can't reallocate Mat with locked size (probably due to misused 'const' modifier)"); for(int j = 0; j < d; ++j) CV_CheckEQ(m.size[j], sizes[j], "Can't reallocate Mat with locked size (probably due to misused 'const' modifier)"); } m.create(d, sizes, mtype); return; } if( k == UMAT ) { CV_Assert( i < 0 ); UMat& m = *(UMat*)obj; CV_Assert(!(m.empty() && fixedType() && fixedSize()) && "Can't reallocate empty UMat with locked layout (probably due to misused 'const' modifier)"); if (!m.empty() && d <= 2 && m.dims <= 2 && m.type() == mtype && ((m.rows == size0 && m.cols == size1) || (allowTransposed && m.rows == size1 && m.cols == size0 && m.isContinuous()))) { return; } if(fixedType()) { if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 ) mtype = m.type(); else CV_CheckTypeEQ(m.type(), CV_MAT_TYPE(mtype), "Can't reallocate UMat with locked type (probably due to misused 'const' modifier)"); } if(fixedSize()) { CV_CheckEQ(m.dims, d, "Can't reallocate UMat with locked size (probably due to misused 'const' modifier)"); for(int j = 0; j < d; ++j) CV_CheckEQ(m.size[j], sizes[j], "Can't reallocate UMat with locked size (probably due to misused 'const' modifier)"); } m.create(d, sizes, mtype); return; } if( k == MATX ) { CV_Assert( i < 0 ); int type0 = CV_MAT_TYPE(flags); CV_Assert( mtype == type0 || (CV_MAT_CN(mtype) == 1 && ((1 << type0) & fixedDepthMask) != 0) ); CV_CheckLE(d, 2, ""); Size requested_size(d == 2 ? sizes[1] : 1, d >= 1 ? sizes[0] : 1); if (sz.width == 1 || sz.height == 1) { // NB: 1D arrays assume allowTransposed=true (see #4159) int total_1d = std::max(sz.width, sz.height); CV_Check(requested_size, std::max(requested_size.width, requested_size.height) == total_1d, ""); } else { if (!allowTransposed) { CV_CheckEQ(requested_size, sz, ""); } else { CV_Check(requested_size, (requested_size == sz || (requested_size.height == sz.width && requested_size.width == sz.height)), ""); } } return; } if( k == STD_VECTOR || k == STD_VECTOR_VECTOR ) { CV_Assert(!fixedSize()); CV_Assert(k == STD_VECTOR_VECTOR || i < 0); CV_Assert( d <= 2 && (size0 == 1 || size1 == 1 || size0*size1 == 0) ); size_t len = size0*size1 > 0 ? size0 + size1 - 1 : 0; int esz = CV_ELEM_SIZE(flags); if( k == STD_VECTOR || (k == STD_VECTOR_VECTOR && i >= 0) ) { int type0 = CV_MAT_TYPE(flags); CV_Assert( mtype == type0 || (CV_MAT_CN(mtype) == CV_MAT_CN(type0) && ((1 << type0) & fixedDepthMask) != 0) ); } #undef RESIZE_VEC #define RESIZE_VEC(T) \ { \ std::vector* v; \ if (k == STD_VECTOR_VECTOR) { \ std::vector >* vv = reinterpret_cast >*>(obj); \ if (i < 0) { \ CV_Assert(!fixedSize() || len == vv->size()); \ vv->resize(len); \ return; \ } \ CV_Assert(size_t(i) < vv->size()); \ v = &vv->at(i); \ } else { \ v = reinterpret_cast*>(obj); \ } \ CV_Assert(!fixedSize() || len == v->size()); \ v->resize(len); \ } \ break STD_VECTOR_SWITCH(esz, RESIZE_VEC) return; } if( k == NONE ) { CV_Error(cv::Error::StsNullPtr, "create() called for the missing output array" ); } if( k == STD_VECTOR_MAT ) { std::vector& v = *(std::vector*)obj; if( i < 0 ) { CV_Assert( d == 2 && (sizes[0] == 1 || sizes[1] == 1 || sizes[0]*sizes[1] == 0) ); size_t len = sizes[0]*sizes[1] > 0 ? sizes[0] + sizes[1] - 1 : 0, len0 = v.size(); CV_Assert(!fixedSize() || len == len0); v.resize(len); if( fixedType() ) { int _type = CV_MAT_TYPE(flags); for( size_t j = len0; j < len; j++ ) { if( v[j].type() == _type ) continue; CV_Assert( v[j].empty() ); v[j].flags = (v[j].flags & ~CV_MAT_TYPE_MASK) | _type; } } return; } CV_Assert( i < (int)v.size() ); Mat& m = v[i]; if( allowTransposed ) { if( !m.isContinuous() ) { CV_Assert(!fixedType() && !fixedSize()); m.release(); } if( d == 2 && m.dims == 2 && m.data && m.type() == mtype && m.rows == sizes[1] && m.cols == sizes[0] ) return; } if(fixedType()) { if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 ) mtype = m.type(); else CV_Assert(CV_MAT_TYPE(mtype) == m.type()); } if(fixedSize()) { CV_Assert(m.dims == d); for(int j = 0; j < d; ++j) CV_Assert(m.size[j] == sizes[j]); } m.create(d, sizes, mtype); return; } if( k == STD_ARRAY_MAT ) { Mat* v = (Mat*)obj; if( i < 0 ) { CV_Assert( d == 2 && (sizes[0] == 1 || sizes[1] == 1 || sizes[0]*sizes[1] == 0) ); size_t len = sizes[0]*sizes[1] > 0 ? sizes[0] + sizes[1] - 1 : 0, len0 = sz.height; CV_Assert(len == len0); if( fixedType() ) { int _type = CV_MAT_TYPE(flags); for( size_t j = len0; j < len; j++ ) { if( v[j].type() == _type ) continue; CV_Assert( v[j].empty() ); v[j].flags = (v[j].flags & ~CV_MAT_TYPE_MASK) | _type; } } return; } CV_Assert( i < sz.height ); Mat& m = v[i]; if( allowTransposed ) { if( !m.isContinuous() ) { CV_Assert(!fixedType() && !fixedSize()); m.release(); } if( d == 2 && m.dims == 2 && m.data && m.type() == mtype && m.rows == sizes[1] && m.cols == sizes[0] ) return; } if(fixedType()) { if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 ) mtype = m.type(); else CV_Assert(CV_MAT_TYPE(mtype) == m.type()); } if(fixedSize()) { CV_Assert(m.dims == d); for(int j = 0; j < d; ++j) CV_Assert(m.size[j] == sizes[j]); } m.create(d, sizes, mtype); return; } if( k == STD_VECTOR_UMAT ) { std::vector& v = *(std::vector*)obj; if( i < 0 ) { CV_Assert( d == 2 && (sizes[0] == 1 || sizes[1] == 1 || sizes[0]*sizes[1] == 0) ); size_t len = sizes[0]*sizes[1] > 0 ? sizes[0] + sizes[1] - 1 : 0, len0 = v.size(); CV_Assert(!fixedSize() || len == len0); v.resize(len); if( fixedType() ) { int _type = CV_MAT_TYPE(flags); for( size_t j = len0; j < len; j++ ) { if( v[j].type() == _type ) continue; CV_Assert( v[j].empty() ); v[j].flags = (v[j].flags & ~CV_MAT_TYPE_MASK) | _type; } } return; } CV_Assert( i < (int)v.size() ); UMat& m = v[i]; if( allowTransposed ) { if( !m.isContinuous() ) { CV_Assert(!fixedType() && !fixedSize()); m.release(); } if( d == 2 && m.dims == 2 && m.u && m.type() == mtype && m.rows == sizes[1] && m.cols == sizes[0] ) return; } if(fixedType()) { if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 ) mtype = m.type(); else CV_Assert(CV_MAT_TYPE(mtype) == m.type()); } if(fixedSize()) { CV_Assert(m.dims == d); for(int j = 0; j < d; ++j) CV_Assert(m.size[j] == sizes[j]); } m.create(d, sizes, mtype); return; } if ((k == CUDA_GPU_MAT || k == CUDA_HOST_MEM) && d <= 2 && i < 0 && !allowTransposed && fixedDepthMask == 0) { create((d < 2 ? 1 : sizes[0]), (d < 1 ? 1 : sizes[d > 1]), mtype, i, allowTransposed, fixedDepthMask); return; } if( k == CUDA_GPU_MATND && d > 0 && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { #ifdef HAVE_CUDA cuda::GpuMatND::SizeArray sizeArray = cuda::GpuMatND::SizeArray(sizes, sizes+d); ((cuda::GpuMatND*)obj)->create(sizeArray, mtype); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } void _OutputArray::create(const MatShape& shape, int mtype, int i, bool allowTransposed, _OutputArray::DepthMask fixedDepthMask) const { if (shape.dims < 0) { release(); } else { create(shape.dims, shape.p, mtype, i, allowTransposed, fixedDepthMask); } } Mat _OutputArray::reinterpret(int mtype) const { mtype = CV_MAT_TYPE(mtype); return getMat().reinterpret(mtype); } void _OutputArray::createSameSize(const _InputArray& arr, int mtype) const { int arrsz[CV_MAX_DIM], d = arr.sizend(arrsz); create(d, arrsz, mtype); } void _OutputArray::fit(int d, const int* sizes, int mtype, int i, bool allowTransposed, _OutputArray::DepthMask fixedDepthMask) const { int size0 = d > 0 ? sizes[0] : 1, size1 = d > 1 ? sizes[1] : 1; _InputArray::KindFlag k = kind(); mtype = CV_MAT_TYPE(mtype); if( (k == MAT && i < 0) || (k == STD_VECTOR_MAT && i >= 0) ) { Mat* m; if (k == MAT) m = (Mat*)obj; else { std::vector& v = *(std::vector*)obj; CV_Assert((size_t)i < v.size()); m = &v[i]; } CV_Assert(!(m->empty() && fixedType() && fixedSize()) && "Can't reallocate empty Mat with locked layout (probably due to misused 'const' modifier)"); if (!m->empty() && d <= 2 && m->dims <= 2 && m->type() == mtype && ((m->rows == size0 && m->cols == size1) || (allowTransposed && m->rows == size1 && m->cols == size0 && m->isContinuous()))) { return; } if(fixedType()) { if(CV_MAT_CN(mtype) == m->channels() && ((1 << CV_MAT_DEPTH(flags)) & fixedDepthMask) != 0 ) mtype = m->type(); else CV_CheckTypeEQ(m->type(), CV_MAT_TYPE(mtype), "Can't reallocate Mat with locked type (probably due to misused 'const' modifier)"); } if(fixedSize()) { CV_CheckEQ(m->dims, d, "Can't reallocate Mat with locked size (probably due to misused 'const' modifier)"); for(int j = 0; j < d; ++j) CV_CheckEQ(m->size[j], sizes[j], "Can't reallocate Mat with locked size (probably due to misused 'const' modifier)"); } m->fit(d, sizes, mtype); return; } if( (k == UMAT && i < 0) || (k == STD_VECTOR_UMAT && i >= 0) ) { UMat* m; if (k == UMAT) m = (UMat*)obj; else { std::vector& v = *(std::vector*)obj; CV_Assert((size_t)i < v.size()); m = &v[i]; } CV_Assert(!(m->empty() && fixedType() && fixedSize()) && "Can't reallocate empty Mat with locked layout (probably due to misused 'const' modifier)"); if (!m->empty() && d <= 2 && m->dims <= 2 && m->type() == mtype && ((m->rows == size0 && m->cols == size1) || (allowTransposed && m->rows == size1 && m->cols == size0 && m->isContinuous()))) { return; } if(fixedType()) { if(CV_MAT_CN(mtype) == m->channels() && ((1 << CV_MAT_DEPTH(flags)) & fixedDepthMask) != 0 ) mtype = m->type(); else CV_CheckTypeEQ(m->type(), CV_MAT_TYPE(mtype), "Can't reallocate Mat with locked type (probably due to misused 'const' modifier)"); } if(fixedSize()) { CV_CheckEQ(m->dims, d, "Can't reallocate Mat with locked size (probably due to misused 'const' modifier)"); for(int j = 0; j < d; ++j) CV_CheckEQ(m->size[j], sizes[j], "Can't reallocate Mat with locked size (probably due to misused 'const' modifier)"); } m->fit(d, sizes, mtype); return; } create(d, sizes, mtype, i, allowTransposed, fixedDepthMask); } void _OutputArray::release() const { CV_Assert(!fixedSize()); _InputArray::KindFlag k = kind(); if( k == MAT ) { ((Mat*)obj)->release(); return; } if( k == UMAT ) { ((UMat*)obj)->release(); return; } if( k == CUDA_GPU_MAT ) { #ifdef HAVE_CUDA ((cuda::GpuMat*)obj)->release(); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if( k == CUDA_GPU_MATND ) { #ifdef HAVE_CUDA ((cuda::GpuMatND*)obj)->release(); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if( k == CUDA_HOST_MEM ) { #ifdef HAVE_CUDA ((cuda::HostMem*)obj)->release(); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } if( k == OPENGL_BUFFER ) { #ifdef HAVE_OPENGL ((ogl::Buffer*)obj)->release(); return; #else CV_Error(Error::StsNotImplemented, "OpenGL support is not enabled in this OpenCV build (missing HAVE_OPENGL)"); #endif } if( k == NONE ) return; if( k == STD_VECTOR || k == STD_VECTOR_VECTOR ) { #undef CLEAR_VEC #define CLEAR_VEC(T) \ if (k == STD_VECTOR_VECTOR) { \ std::vector >* vv = \ reinterpret_cast >*>(obj); \ vv->clear(); \ } else { \ std::vector* v = reinterpret_cast*>(obj); \ v->clear(); \ } \ break int esz = CV_ELEM_SIZE(flags); STD_VECTOR_SWITCH(esz, CLEAR_VEC); return; } if( k == STD_VECTOR_MAT ) { ((std::vector*)obj)->clear(); return; } if( k == STD_BOOL_VECTOR ) { ((std::vector*)obj)->clear(); return; } if( k == STD_VECTOR_UMAT ) { ((std::vector*)obj)->clear(); return; } if (k == STD_VECTOR_CUDA_GPU_MAT) { #ifdef HAVE_CUDA ((std::vector*)obj)->clear(); return; #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } CV_Error(Error::StsNotImplemented, "Unknown/unsupported array type"); } void _OutputArray::clear() const { _InputArray::KindFlag k = kind(); if( k == MAT ) { CV_Assert(!fixedSize()); ((Mat*)obj)->resize(0); return; } release(); } bool _OutputArray::needed() const { return kind() != NONE; } Mat& _OutputArray::getMatRef(int i) const { _InputArray::KindFlag k = kind(); if( i < 0 ) { CV_Assert( k == MAT ); return *(Mat*)obj; } CV_Assert( k == STD_VECTOR_MAT || k == STD_ARRAY_MAT ); if( k == STD_VECTOR_MAT ) { std::vector& v = *(std::vector*)obj; CV_Assert( i < (int)v.size() ); return v[i]; } else { Mat* v = (Mat*)obj; CV_Assert( 0 <= i && i < sz.height ); return v[i]; } } UMat& _OutputArray::getUMatRef(int i) const { _InputArray::KindFlag k = kind(); if( i < 0 ) { CV_Assert( k == UMAT ); return *(UMat*)obj; } else { CV_Assert( k == STD_VECTOR_UMAT ); std::vector& v = *(std::vector*)obj; CV_Assert( i < (int)v.size() ); return v[i]; } } cuda::GpuMat& _OutputArray::getGpuMatRef() const { _InputArray::KindFlag k = kind(); CV_Assert( k == CUDA_GPU_MAT ); return *(cuda::GpuMat*)obj; } std::vector& _OutputArray::getGpuMatVecRef() const { _InputArray::KindFlag k = kind(); CV_Assert(k == STD_VECTOR_CUDA_GPU_MAT); return *(std::vector*)obj; } cuda::GpuMatND& _OutputArray::getGpuMatNDRef() const { _InputArray::KindFlag k = kind(); CV_Assert( k == CUDA_GPU_MATND ); return *(cuda::GpuMatND*)obj; } std::vector& _OutputArray::getGpuMatNDVecRef() const { _InputArray::KindFlag k = kind(); CV_Assert(k == STD_VECTOR_CUDA_GPU_MAT_ND); return *(std::vector*)obj; } ogl::Buffer& _OutputArray::getOGlBufferRef() const { _InputArray::KindFlag k = kind(); CV_Assert( k == OPENGL_BUFFER ); return *(ogl::Buffer*)obj; } cuda::HostMem& _OutputArray::getHostMemRef() const { _InputArray::KindFlag k = kind(); CV_Assert( k == CUDA_HOST_MEM ); return *(cuda::HostMem*)obj; } void _OutputArray::setTo(const _InputArray& arr, const _InputArray & mask) const { _InputArray::KindFlag k = kind(); if( k == NONE ) ; else if (k == MAT || k == MATX || k == STD_VECTOR) { Mat m = getMat(); m.setTo(arr, mask); } else if( k == UMAT ) ((UMat*)obj)->setTo(arr, mask); else if( k == CUDA_GPU_MAT ) { #ifdef HAVE_CUDA Mat value = arr.getMat(); CV_Assert( checkScalar(value, type(), arr.kind(), _InputArray::CUDA_GPU_MAT) ); ((cuda::GpuMat*)obj)->setTo(Scalar(Vec(value.ptr())), mask); #else CV_Error(Error::StsNotImplemented, "CUDA support is not enabled in this OpenCV build (missing HAVE_CUDA)"); #endif } else CV_Error(Error::StsNotImplemented, ""); } void _OutputArray::setZero() const { _InputArray::KindFlag k = kind(); if( k == NONE ) ; else if (k == MAT || k == MATX || k == STD_VECTOR) { Mat m = getMat(); m.setZero(); } else { setTo(Scalar::all(0), noArray()); } } void _OutputArray::assign(const UMat& u) const { _InputArray::KindFlag k = kind(); if (k == UMAT) { *(UMat*)obj = u; } else if (k == MAT) { u.copyTo(*(Mat*)obj); // TODO check u.getMat() } else if (k == MATX) { u.copyTo(getMat()); // TODO check u.getMat() } else { CV_Error(Error::StsNotImplemented, ""); } } void _OutputArray::assign(const Mat& m) const { _InputArray::KindFlag k = kind(); if (k == UMAT) { m.copyTo(*(UMat*)obj); // TODO check m.getUMat() } else if (k == MAT) { *(Mat*)obj = m; } else if (k == MATX) { m.copyTo(getMat()); } else { CV_Error(Error::StsNotImplemented, ""); } } void _OutputArray::move(UMat& u) const { if (fixedSize()) { // TODO Performance warning assign(u); return; } int k = kind(); if (k == UMAT) { *(UMat*)obj = std::move(u); } else if (k == MAT) { u.copyTo(*(Mat*)obj); // TODO check u.getMat() u.release(); } else if (k == MATX) { u.copyTo(getMat()); // TODO check u.getMat() u.release(); } else { CV_Error(Error::StsNotImplemented, ""); } } void _OutputArray::move(Mat& m) const { if (fixedSize()) { // TODO Performance warning assign(m); return; } int k = kind(); if (k == UMAT) { m.copyTo(*(UMat*)obj); // TODO check m.getUMat() m.release(); } else if (k == MAT) { *(Mat*)obj = std::move(m); } else if (k == MATX) { m.copyTo(getMat()); m.release(); } else { CV_Error(Error::StsNotImplemented, ""); } } void _OutputArray::assign(const std::vector& v) const { _InputArray::KindFlag k = kind(); if (k == STD_VECTOR_UMAT) { std::vector& this_v = *(std::vector*)obj; CV_Assert(this_v.size() == v.size()); for (size_t i = 0; i < v.size(); i++) { const UMat& m = v[i]; UMat& this_m = this_v[i]; if (this_m.u != NULL && this_m.u == m.u) continue; // same object (see dnn::Layer::forward_fallback) m.copyTo(this_m); } } else if (k == STD_VECTOR_MAT) { std::vector& this_v = *(std::vector*)obj; CV_Assert(this_v.size() == v.size()); for (size_t i = 0; i < v.size(); i++) { const UMat& m = v[i]; Mat& this_m = this_v[i]; if (this_m.u != NULL && this_m.u == m.u) continue; // same object (see dnn::Layer::forward_fallback) m.copyTo(this_m); } } else { CV_Error(Error::StsNotImplemented, ""); } } void _OutputArray::assign(const std::vector& v) const { _InputArray::KindFlag k = kind(); if (k == STD_VECTOR_UMAT) { std::vector& this_v = *(std::vector*)obj; CV_Assert(this_v.size() == v.size()); for (size_t i = 0; i < v.size(); i++) { const Mat& m = v[i]; UMat& this_m = this_v[i]; if (this_m.u != NULL && this_m.u == m.u) continue; // same object (see dnn::Layer::forward_fallback) m.copyTo(this_m); } } else if (k == STD_VECTOR_MAT) { std::vector& this_v = *(std::vector*)obj; CV_Assert(this_v.size() == v.size()); for (size_t i = 0; i < v.size(); i++) { const Mat& m = v[i]; Mat& this_m = this_v[i]; if (this_m.u != NULL && this_m.u == m.u) continue; // same object (see dnn::Layer::forward_fallback) m.copyTo(this_m); } } else { CV_Error(Error::StsNotImplemented, ""); } } static _InputOutputArray _none; InputOutputArray noArray() { return _none; } } // cv::