#include "opencv2/core/bufferpool.hpp"
-#ifdef CV_CXX11
#include <type_traits>
-#endif
namespace cv
{
//! @addtogroup core_basic
//! @{
-enum { ACCESS_READ=1<<24, ACCESS_WRITE=1<<25,
+enum AccessFlag { ACCESS_READ=1<<24, ACCESS_WRITE=1<<25,
ACCESS_RW=3<<24, ACCESS_MASK=ACCESS_RW, ACCESS_FAST=1<<26 };
+CV_ENUM_FLAGS(AccessFlag)
+__CV_ENUM_FLAGS_BITWISE_AND(AccessFlag, int, AccessFlag)
CV__DEBUG_NS_BEGIN
class CV_EXPORTS _InputArray
{
public:
- enum {
+ enum KindFlag {
KIND_SHIFT = 16,
FIXED_TYPE = 0x8000 << KIND_SHIFT,
FIXED_SIZE = 0x4000 << KIND_SHIFT,
template<typename _Tp> _InputArray(const std::vector<_Tp>& vec);
_InputArray(const std::vector<bool>& vec);
template<typename _Tp> _InputArray(const std::vector<std::vector<_Tp> >& vec);
- _InputArray(const std::vector<std::vector<bool> >&);
+ _InputArray(const std::vector<std::vector<bool> >&) = delete; // not supported
template<typename _Tp> _InputArray(const std::vector<Mat_<_Tp> >& vec);
template<typename _Tp> _InputArray(const _Tp* vec, int n);
template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
_InputArray(const UMat& um);
_InputArray(const std::vector<UMat>& umv);
-#ifdef CV_CXX_STD_ARRAY
template<typename _Tp, std::size_t _Nm> _InputArray(const std::array<_Tp, _Nm>& arr);
template<std::size_t _Nm> _InputArray(const std::array<Mat, _Nm>& arr);
-#endif
template<typename _Tp> static _InputArray rawIn(const std::vector<_Tp>& vec);
-#ifdef CV_CXX_STD_ARRAY
template<typename _Tp, std::size_t _Nm> static _InputArray rawIn(const std::array<_Tp, _Nm>& arr);
-#endif
Mat getMat(int idx=-1) const;
Mat getMat_(int idx=-1) const;
void* getObj() const;
Size getSz() const;
- int kind() const;
+ _InputArray::KindFlag kind() const;
int dims(int i=-1) const;
int cols(int i=-1) const;
int rows(int i=-1) const;
void init(int _flags, const void* _obj);
void init(int _flags, const void* _obj, Size _sz);
};
-
+CV_ENUM_FLAGS(_InputArray::KindFlag)
+__CV_ENUM_FLAGS_BITWISE_AND(_InputArray::KindFlag, int, _InputArray::KindFlag)
/** @brief This type is very similar to InputArray except that it is used for input/output and output function
parameters.
class CV_EXPORTS _OutputArray : public _InputArray
{
public:
- enum
+ enum DepthMask
{
DEPTH_MASK_8U = 1 << CV_8U,
DEPTH_MASK_8S = 1 << CV_8S,
DEPTH_MASK_32S = 1 << CV_32S,
DEPTH_MASK_32F = 1 << CV_32F,
DEPTH_MASK_64F = 1 << CV_64F,
+ DEPTH_MASK_16F = 1 << CV_16F,
DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
+ DEPTH_MASK_ALL_16F = (DEPTH_MASK_16F<<1)-1,
DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
};
_OutputArray(cuda::HostMem& cuda_mem);
template<typename _Tp> _OutputArray(cudev::GpuMat_<_Tp>& m);
template<typename _Tp> _OutputArray(std::vector<_Tp>& vec);
- _OutputArray(std::vector<bool>& vec);
+ _OutputArray(std::vector<bool>& vec) = delete; // not supported
template<typename _Tp> _OutputArray(std::vector<std::vector<_Tp> >& vec);
- _OutputArray(std::vector<std::vector<bool> >&);
+ _OutputArray(std::vector<std::vector<bool> >&) = delete; // not supported
template<typename _Tp> _OutputArray(std::vector<Mat_<_Tp> >& vec);
template<typename _Tp> _OutputArray(Mat_<_Tp>& m);
template<typename _Tp> _OutputArray(_Tp* vec, int n);
_OutputArray(const UMat& m);
_OutputArray(const std::vector<UMat>& vec);
-#ifdef CV_CXX_STD_ARRAY
template<typename _Tp, std::size_t _Nm> _OutputArray(std::array<_Tp, _Nm>& arr);
template<typename _Tp, std::size_t _Nm> _OutputArray(const std::array<_Tp, _Nm>& arr);
template<std::size_t _Nm> _OutputArray(std::array<Mat, _Nm>& arr);
template<std::size_t _Nm> _OutputArray(const std::array<Mat, _Nm>& arr);
-#endif
template<typename _Tp> static _OutputArray rawOut(std::vector<_Tp>& vec);
-#ifdef CV_CXX_STD_ARRAY
template<typename _Tp, std::size_t _Nm> static _OutputArray rawOut(std::array<_Tp, _Nm>& arr);
-#endif
bool fixedSize() const;
bool fixedType() const;
std::vector<cuda::GpuMat>& getGpuMatVecRef() const;
ogl::Buffer& getOGlBufferRef() const;
cuda::HostMem& getHostMemRef() const;
- void create(Size sz, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
- void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
- void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
+ void create(Size sz, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
+ void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
+ void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
void createSameSize(const _InputArray& arr, int mtype) const;
void release() const;
void clear() const;
_InputOutputArray(cuda::HostMem& cuda_mem);
template<typename _Tp> _InputOutputArray(cudev::GpuMat_<_Tp>& m);
template<typename _Tp> _InputOutputArray(std::vector<_Tp>& vec);
- _InputOutputArray(std::vector<bool>& vec);
+ _InputOutputArray(std::vector<bool>& vec) = delete; // not supported
template<typename _Tp> _InputOutputArray(std::vector<std::vector<_Tp> >& vec);
template<typename _Tp> _InputOutputArray(std::vector<Mat_<_Tp> >& vec);
template<typename _Tp> _InputOutputArray(Mat_<_Tp>& m);
_InputOutputArray(const UMat& m);
_InputOutputArray(const std::vector<UMat>& vec);
-#ifdef CV_CXX_STD_ARRAY
template<typename _Tp, std::size_t _Nm> _InputOutputArray(std::array<_Tp, _Nm>& arr);
template<typename _Tp, std::size_t _Nm> _InputOutputArray(const std::array<_Tp, _Nm>& arr);
template<std::size_t _Nm> _InputOutputArray(std::array<Mat, _Nm>& arr);
template<std::size_t _Nm> _InputOutputArray(const std::array<Mat, _Nm>& arr);
-#endif
template<typename _Tp> static _InputOutputArray rawInOut(std::vector<_Tp>& vec);
-#ifdef CV_CXX_STD_ARRAY
template<typename _Tp, std::size_t _Nm> _InputOutputArray rawInOut(std::array<_Tp, _Nm>& arr);
-#endif
};
// uchar*& datastart, uchar*& data, size_t* step) = 0;
//virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
virtual UMatData* allocate(int dims, const int* sizes, int type,
- void* data, size_t* step, int flags, UMatUsageFlags usageFlags) const = 0;
- virtual bool allocate(UMatData* data, int accessflags, UMatUsageFlags usageFlags) const = 0;
+ void* data, size_t* step, AccessFlag flags, UMatUsageFlags usageFlags) const = 0;
+ virtual bool allocate(UMatData* data, AccessFlag accessflags, UMatUsageFlags usageFlags) const = 0;
virtual void deallocate(UMatData* data) const = 0;
- virtual void map(UMatData* data, int accessflags) const;
+ virtual void map(UMatData* data, AccessFlag accessflags) const;
virtual void unmap(UMatData* data) const;
virtual void download(UMatData* data, void* dst, int dims, const size_t sz[],
const size_t srcofs[], const size_t srcstep[],
// it should be explicitly initialized using init().
struct CV_EXPORTS UMatData
{
- enum { COPY_ON_MAP=1, HOST_COPY_OBSOLETE=2,
+ enum MemoryFlag { COPY_ON_MAP=1, HOST_COPY_OBSOLETE=2,
DEVICE_COPY_OBSOLETE=4, TEMP_UMAT=8, TEMP_COPIED_UMAT=24,
USER_ALLOCATED=32, DEVICE_MEM_MAPPED=64,
ASYNC_CLEANUP=128
uchar* origdata;
size_t size;
- int flags;
+ UMatData::MemoryFlag flags;
void* handle;
void* userdata;
int allocatorFlags_;
int mapcount;
UMatData* originalUMatData;
+ std::shared_ptr<void> allocatorContext;
};
+CV_ENUM_FLAGS(UMatData::MemoryFlag)
struct CV_EXPORTS MatSize
that 2-dimensional matrices are stored row-by-row, 3-dimensional matrices are stored plane-by-plane,
and so on. M.step[M.dims-1] is minimal and always equal to the element size M.elemSize() .
-So, the data layout in Mat is fully compatible with CvMat, IplImage, and CvMatND types from OpenCV
-1.x. It is also compatible with the majority of dense array types from the standard toolkits and
-SDKs, such as Numpy (ndarray), Win32 (independent device bitmaps), and others, that is, with any
-array that uses *steps* (or *strides*) to compute the position of a pixel. Due to this
-compatibility, it is possible to make a Mat header for user-allocated data and process it in-place
-using OpenCV functions.
+So, the data layout in Mat is compatible with the majority of dense array types from the standard
+toolkits and SDKs, such as Numpy (ndarray), Win32 (independent device bitmaps), and others,
+that is, with any array that uses *steps* (or *strides*) to compute the position of a pixel.
+Due to this compatibility, it is possible to make a Mat header for user-allocated data and process
+it in-place using OpenCV functions.
There are many different ways to create a Mat object. The most popular options are listed below:
Mat M = Mat(3, 3, CV_64F, m).inv();
@endcode
.
- Partial yet very common cases of this *user-allocated data* case are conversions from CvMat and
- IplImage to Mat. For this purpose, there is function cv::cvarrToMat taking pointers to CvMat or
- IplImage and the optional flag indicating whether to copy the data or not.
- @snippet samples/cpp/image.cpp iplimage
- Use MATLAB-style array initializers, zeros(), ones(), eye(), for example:
@code
*/
template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
-#ifdef CV_CXX11
/** @overload
*/
template<typename _Tp, typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>
/** @overload
*/
template<typename _Tp> explicit Mat(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> list);
-#endif
-#ifdef CV_CXX_STD_ARRAY
/** @overload
*/
template<typename _Tp, size_t _Nm> explicit Mat(const std::array<_Tp, _Nm>& arr, bool copyData=false);
-#endif
/** @overload
*/
Mat& operator = (const MatExpr& expr);
//! retrieve UMat from Mat
- UMat getUMat(int accessFlags, UMatUsageFlags usageFlags = USAGE_DEFAULT) const;
+ UMat getUMat(AccessFlag accessFlags, UMatUsageFlags usageFlags = USAGE_DEFAULT) const;
/** @brief Creates a matrix header for the specified matrix row.
*/
Mat operator()(const std::vector<Range>& ranges) const;
- // //! converts header to CvMat; no data is copied
- // operator CvMat() const;
- // //! converts header to CvMatND; no data is copied
- // operator CvMatND() const;
- // //! converts header to IplImage; no data is copied
- // operator IplImage() const;
-
template<typename _Tp> operator std::vector<_Tp>() const;
template<typename _Tp, int n> operator Vec<_Tp, n>() const;
template<typename _Tp, int m, int n> operator Matx<_Tp, m, n>() const;
-#ifdef CV_CXX_STD_ARRAY
template<typename _Tp, std::size_t _Nm> operator std::array<_Tp, _Nm>() const;
-#endif
/** @brief Reports whether the matrix is continuous or not.
/** @overload */
template<typename _Tp, typename Functor> void forEach(const Functor& operation) const;
-#ifdef CV_CXX_MOVE_SEMANTICS
Mat(Mat&& m);
Mat& operator = (Mat&& m);
-#endif
enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
explicit Mat_(const MatCommaInitializer_<_Tp>& commaInitializer);
-#ifdef CV_CXX11
Mat_(std::initializer_list<_Tp> values);
explicit Mat_(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> values);
-#endif
-#ifdef CV_CXX_STD_ARRAY
template <std::size_t _Nm> explicit Mat_(const std::array<_Tp, _Nm>& arr, bool copyData=false);
-#endif
Mat_& operator = (const Mat& m);
Mat_& operator = (const Mat_& m);
//! conversion to vector.
operator std::vector<_Tp>() const;
-#ifdef CV_CXX_STD_ARRAY
//! conversion to array.
template<std::size_t _Nm> operator std::array<_Tp, _Nm>() const;
-#endif
//! conversion to Vec
template<int n> operator Vec<typename DataType<_Tp>::channel_type, n>() const;
//! conversion to Matx
template<int m, int n> operator Matx<typename DataType<_Tp>::channel_type, m, n>() const;
-#ifdef CV_CXX_MOVE_SEMANTICS
Mat_(Mat_&& m);
Mat_& operator = (Mat_&& m);
Mat_& operator = (Mat&& m);
Mat_(MatExpr&& e);
-#endif
};
typedef Mat_<uchar> Mat1b;
//! assignment operators
UMat& operator = (const UMat& m);
- Mat getMat(int flags) const;
+ Mat getMat(AccessFlag flags) const;
//! returns a new matrix header for the specified row
UMat row(int y) const;
//! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise
int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
-#ifdef CV_CXX_MOVE_SEMANTICS
UMat(UMat&& m);
UMat& operator = (UMat&& m);
-#endif
/*! Returns the OpenCL buffer handle on which UMat operates on.
The UMat instance should be kept alive during the use of the handle to prevent the buffer to be
returned to the OpenCV buffer pool.
*/
- void* handle(int accessFlags) const;
+ void* handle(AccessFlag accessFlags) const;
void ndoffset(size_t* ofs) const;
enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
projects / platform / upstream / opencv.git / blobdiff