|
| class | cv::_InputArray |
| | This is the proxy class for passing read-only input arrays into OpenCV functions. More...
|
| |
| class | cv::_InputOutputArray |
| |
| class | cv::_OutputArray |
| | This type is very similar to InputArray except that it is used for input/output and output function parameters. More...
|
| |
| class | cv::Algorithm |
| | This is a base class for all more or less complex algorithms in OpenCV. More...
|
| |
| class | cv::Complex< _Tp > |
| | A complex number class. More...
|
| |
| class | cv::DataDepth< _Tp > |
| | A helper class for cv::DataType. More...
|
| |
| class | cv::DataType< _Tp > |
| | Template "trait" class for OpenCV primitive data types. More...
|
| |
| class | cv::DMatch |
| | Class for matching keypoint descriptors. More...
|
| |
| class | cv::Formatted |
| |
| class | cv::Formatter |
| |
| struct | cv::SparseMat::Hdr |
| | the sparse matrix header More...
|
| |
| class | cv::KeyPoint |
| | Data structure for salient point detectors. More...
|
| |
| class | cv::Mat |
| | n-dimensional dense array class More...
|
| |
| class | cv::Mat_< _Tp > |
| | Template matrix class derived from Mat. More...
|
| |
| class | cv::MatAllocator |
| | Custom array allocator. More...
|
| |
| class | cv::MatCommaInitializer_< _Tp > |
| | Comma-separated Matrix Initializer. More...
|
| |
| class | cv::MatConstIterator |
| |
| class | cv::MatConstIterator_< _Tp > |
| | Matrix read-only iterator. More...
|
| |
| class | cv::MatExpr |
| | Matrix expression representation. More...
|
| |
| class | cv::MatIterator_< _Tp > |
| | Matrix read-write iterator. More...
|
| |
| class | cv::MatOp |
| |
| struct | cv::MatSize |
| |
| struct | cv::MatStep |
| |
| class | cv::Matx< _Tp, m, n > |
| | Template class for small matrices whose type and size are known at compilation time. More...
|
| |
| class | cv::MatxCommaInitializer< _Tp, m, n > |
| | Comma-separated Matrix Initializer. More...
|
| |
| class | cv::NAryMatIterator |
| | n-ary multi-dimensional array iterator. More...
|
| |
| struct | cv::SparseMat::Node |
| | sparse matrix node - element of a hash table More...
|
| |
| struct | cv::ParamType< _Tp, _EnumTp > |
| |
| struct | cv::ParamType< _Tp, typename std::enable_if< std::is_enum< _Tp >::value >::type > |
| |
| struct | cv::ParamType< Algorithm > |
| |
| struct | cv::ParamType< bool > |
| |
| struct | cv::ParamType< double > |
| |
| struct | cv::ParamType< float > |
| |
| struct | cv::ParamType< Mat > |
| |
| struct | cv::ParamType< Scalar > |
| |
| struct | cv::ParamType< std::vector< Mat > > |
| |
| struct | cv::ParamType< String > |
| |
| struct | cv::ParamType< uchar > |
| |
| struct | cv::ParamType< uint64 > |
| |
| struct | cv::ParamType< unsigned > |
| |
| class | cv::Point3_< _Tp > |
| | Template class for 3D points specified by its coordinates x, y and z. More...
|
| |
| class | cv::Point_< _Tp > |
| | Template class for 2D points specified by its coordinates x and y. More...
|
| |
| class | cv::Range |
| | Template class specifying a continuous subsequence (slice) of a sequence. More...
|
| |
| class | cv::Rect_< _Tp > |
| | Template class for 2D rectangles. More...
|
| |
| class | cv::RotatedRect |
| | The class represents rotated (i.e. not up-right) rectangles on a plane. More...
|
| |
| class | cv::Scalar_< _Tp > |
| | Template class for a 4-element vector derived from Vec. More...
|
| |
| class | cv::Size_< _Tp > |
| | Template class for specifying the size of an image or rectangle. More...
|
| |
| class | cv::SparseMat |
| | The class SparseMat represents multi-dimensional sparse numerical arrays. More...
|
| |
| class | cv::SparseMat_< _Tp > |
| | Template sparse n-dimensional array class derived from SparseMat. More...
|
| |
| class | cv::SparseMatConstIterator |
| | Read-Only Sparse Matrix Iterator. More...
|
| |
| class | cv::SparseMatConstIterator_< _Tp > |
| | Template Read-Only Sparse Matrix Iterator Class. More...
|
| |
| class | cv::SparseMatIterator |
| | Read-write Sparse Matrix Iterator. More...
|
| |
| class | cv::SparseMatIterator_< _Tp > |
| | Template Read-Write Sparse Matrix Iterator Class. More...
|
| |
| class | cv::TermCriteria |
| | The class defining termination criteria for iterative algorithms. More...
|
| |
| class | cv::UMat |
| |
| struct | cv::UMatData |
| |
| class | cv::Vec< _Tp, cn > |
| | Template class for short numerical vectors, a partial case of Matx. More...
|
| |
| class | cv::VecCommaInitializer< _Tp, m > |
| | Comma-separated Vec Initializer. More...
|
| |
|
| typedef Complex< double > | cv::Complexd |
| |
| typedef Complex< float > | cv::Complexf |
| |
| typedef const _InputArray & | cv::InputArray |
| |
| typedef InputArray | cv::InputArrayOfArrays |
| |
| typedef const _InputOutputArray & | cv::InputOutputArray |
| |
| typedef InputOutputArray | cv::InputOutputArrayOfArrays |
| |
| typedef Mat_< uchar > | cv::Mat1b |
| |
| typedef Mat_< double > | cv::Mat1d |
| |
| typedef Mat_< float > | cv::Mat1f |
| |
| typedef Mat_< int > | cv::Mat1i |
| |
| typedef Mat_< short > | cv::Mat1s |
| |
| typedef Mat_< ushort > | cv::Mat1w |
| |
| typedef Mat_< Vec2b > | cv::Mat2b |
| |
| typedef Mat_< Vec2d > | cv::Mat2d |
| |
| typedef Mat_< Vec2f > | cv::Mat2f |
| |
| typedef Mat_< Vec2i > | cv::Mat2i |
| |
| typedef Mat_< Vec2s > | cv::Mat2s |
| |
| typedef Mat_< Vec2w > | cv::Mat2w |
| |
| typedef Mat_< Vec3b > | cv::Mat3b |
| |
| typedef Mat_< Vec3d > | cv::Mat3d |
| |
| typedef Mat_< Vec3f > | cv::Mat3f |
| |
| typedef Mat_< Vec3i > | cv::Mat3i |
| |
| typedef Mat_< Vec3s > | cv::Mat3s |
| |
| typedef Mat_< Vec3w > | cv::Mat3w |
| |
| typedef Mat_< Vec4b > | cv::Mat4b |
| |
| typedef Mat_< Vec4d > | cv::Mat4d |
| |
| typedef Mat_< Vec4f > | cv::Mat4f |
| |
| typedef Mat_< Vec4i > | cv::Mat4i |
| |
| typedef Mat_< Vec4s > | cv::Mat4s |
| |
| typedef Mat_< Vec4w > | cv::Mat4w |
| |
| typedef Matx< double, 1, 2 > | cv::Matx12d |
| |
| typedef Matx< float, 1, 2 > | cv::Matx12f |
| |
| typedef Matx< double, 1, 3 > | cv::Matx13d |
| |
| typedef Matx< float, 1, 3 > | cv::Matx13f |
| |
| typedef Matx< double, 1, 4 > | cv::Matx14d |
| |
| typedef Matx< float, 1, 4 > | cv::Matx14f |
| |
| typedef Matx< double, 1, 6 > | cv::Matx16d |
| |
| typedef Matx< float, 1, 6 > | cv::Matx16f |
| |
| typedef Matx< double, 2, 1 > | cv::Matx21d |
| |
| typedef Matx< float, 2, 1 > | cv::Matx21f |
| |
| typedef Matx< double, 2, 2 > | cv::Matx22d |
| |
| typedef Matx< float, 2, 2 > | cv::Matx22f |
| |
| typedef Matx< double, 2, 3 > | cv::Matx23d |
| |
| typedef Matx< float, 2, 3 > | cv::Matx23f |
| |
| typedef Matx< double, 3, 1 > | cv::Matx31d |
| |
| typedef Matx< float, 3, 1 > | cv::Matx31f |
| |
| typedef Matx< double, 3, 2 > | cv::Matx32d |
| |
| typedef Matx< float, 3, 2 > | cv::Matx32f |
| |
| typedef Matx< double, 3, 3 > | cv::Matx33d |
| |
| typedef Matx< float, 3, 3 > | cv::Matx33f |
| |
| typedef Matx< double, 3, 4 > | cv::Matx34d |
| |
| typedef Matx< float, 3, 4 > | cv::Matx34f |
| |
| typedef Matx< double, 4, 1 > | cv::Matx41d |
| |
| typedef Matx< float, 4, 1 > | cv::Matx41f |
| |
| typedef Matx< double, 4, 3 > | cv::Matx43d |
| |
| typedef Matx< float, 4, 3 > | cv::Matx43f |
| |
| typedef Matx< double, 4, 4 > | cv::Matx44d |
| |
| typedef Matx< float, 4, 4 > | cv::Matx44f |
| |
| typedef Matx< double, 6, 1 > | cv::Matx61d |
| |
| typedef Matx< float, 6, 1 > | cv::Matx61f |
| |
| typedef Matx< double, 6, 6 > | cv::Matx66d |
| |
| typedef Matx< float, 6, 6 > | cv::Matx66f |
| |
| typedef const _OutputArray & | cv::OutputArray |
| |
| typedef OutputArray | cv::OutputArrayOfArrays |
| |
| typedef Point2i | cv::Point |
| |
| typedef Point_< double > | cv::Point2d |
| |
| typedef Point_< float > | cv::Point2f |
| |
| typedef Point_< int > | cv::Point2i |
| |
| typedef Point_< int64 > | cv::Point2l |
| |
| typedef Point3_< double > | cv::Point3d |
| |
| typedef Point3_< float > | cv::Point3f |
| |
| typedef Point3_< int > | cv::Point3i |
| |
| template<typename _Tp > |
| using | cv::Ptr = std::shared_ptr< _Tp > |
| |
| typedef Rect2i | cv::Rect |
| |
| typedef Rect_< double > | cv::Rect2d |
| |
| typedef Rect_< float > | cv::Rect2f |
| |
| typedef Rect_< int > | cv::Rect2i |
| |
| typedef Scalar_< double > | cv::Scalar |
| |
| typedef Size2i | cv::Size |
| |
| typedef Size_< double > | cv::Size2d |
| |
| typedef Size_< float > | cv::Size2f |
| |
| typedef Size_< int > | cv::Size2i |
| |
| typedef Size_< int64 > | cv::Size2l |
| |
| typedef std::string | cv::String |
| |
|
| enum | {
cv::Mat::MAGIC_VAL = 0x42FF0000,
cv::Mat::AUTO_STEP = 0,
cv::Mat::CONTINUOUS_FLAG = CV_MAT_CONT_FLAG,
cv::Mat::SUBMATRIX_FLAG = CV_SUBMAT_FLAG
} |
| |
| enum | {
cv::Mat::MAGIC_MASK = 0xFFFF0000,
cv::Mat::TYPE_MASK = 0x00000FFF,
cv::Mat::DEPTH_MASK = 7
} |
| |
| enum | {
cv::UMat::MAGIC_VAL = 0x42FF0000,
cv::UMat::AUTO_STEP = 0,
cv::UMat::CONTINUOUS_FLAG = CV_MAT_CONT_FLAG,
cv::UMat::SUBMATRIX_FLAG = CV_SUBMAT_FLAG
} |
| |
| enum | {
cv::UMat::MAGIC_MASK = 0xFFFF0000,
cv::UMat::TYPE_MASK = 0x00000FFF,
cv::UMat::DEPTH_MASK = 7
} |
| |
| enum | {
cv::SparseMat::MAGIC_VAL =0x42FD0000,
cv::SparseMat::MAX_DIM =32,
cv::SparseMat::HASH_SCALE =0x5bd1e995,
cv::SparseMat::HASH_BIT =0x80000000
} |
| |
| enum | {
cv::Matx< _Tp, m, n >::rows = m,
cv::Matx< _Tp, m, n >::cols = n,
cv::Matx< _Tp, m, n >::channels = rows*cols,
cv::Matx< _Tp, m, n >::shortdim = (m < n ? m : n)
} |
| |
| enum | {
cv::Vec< _Tp, cn >::channels = cn,
cv::Vec< _Tp, cn >::_dummy_enum_finalizer = 0
} |
| |
| enum | {
cv::DataDepth< _Tp >::value = DataType<_Tp>::depth,
cv::DataDepth< _Tp >::fmt = DataType<_Tp>::fmt
} |
| |
| enum | cv::AccessFlag {
cv::ACCESS_READ =1<<24,
cv::ACCESS_WRITE =1<<25,
cv::ACCESS_RW =3<<24,
cv::ACCESS_MASK =ACCESS_RW,
cv::ACCESS_FAST =1<<26
} |
| |
| enum | cv::_OutputArray::DepthMask {
cv::_OutputArray::DEPTH_MASK_8U = 1 << CV_8U,
cv::_OutputArray::DEPTH_MASK_8S = 1 << CV_8S,
cv::_OutputArray::DEPTH_MASK_16U = 1 << CV_16U,
cv::_OutputArray::DEPTH_MASK_16S = 1 << CV_16S,
cv::_OutputArray::DEPTH_MASK_32S = 1 << CV_32S,
cv::_OutputArray::DEPTH_MASK_32F = 1 << CV_32F,
cv::_OutputArray::DEPTH_MASK_64F = 1 << CV_64F,
cv::_OutputArray::DEPTH_MASK_16F = 1 << CV_16F,
cv::_OutputArray::DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
cv::_OutputArray::DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
cv::_OutputArray::DEPTH_MASK_ALL_16F = (DEPTH_MASK_16F<<1)-1,
cv::_OutputArray::DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
} |
| |
| enum | cv::Formatter::FormatType {
cv::Formatter::FMT_DEFAULT = 0,
cv::Formatter::FMT_MATLAB = 1,
cv::Formatter::FMT_CSV = 2,
cv::Formatter::FMT_PYTHON = 3,
cv::Formatter::FMT_NUMPY = 4,
cv::Formatter::FMT_C = 5
} |
| |
| enum | cv::_InputArray::KindFlag {
cv::_InputArray::KIND_SHIFT = 16,
cv::_InputArray::FIXED_TYPE = 0x8000 << KIND_SHIFT,
cv::_InputArray::FIXED_SIZE = 0x4000 << KIND_SHIFT,
cv::_InputArray::KIND_MASK = 31 << KIND_SHIFT,
cv::_InputArray::NONE = 0 << KIND_SHIFT,
cv::_InputArray::MAT = 1 << KIND_SHIFT,
cv::_InputArray::MATX = 2 << KIND_SHIFT,
cv::_InputArray::STD_VECTOR = 3 << KIND_SHIFT,
cv::_InputArray::STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
cv::_InputArray::STD_VECTOR_MAT = 5 << KIND_SHIFT,
cv::_InputArray::EXPR = 6 << KIND_SHIFT,
cv::_InputArray::OPENGL_BUFFER = 7 << KIND_SHIFT,
cv::_InputArray::CUDA_HOST_MEM = 8 << KIND_SHIFT,
cv::_InputArray::CUDA_GPU_MAT = 9 << KIND_SHIFT,
cv::_InputArray::UMAT =10 << KIND_SHIFT,
cv::_InputArray::STD_VECTOR_UMAT =11 << KIND_SHIFT,
cv::_InputArray::STD_BOOL_VECTOR =12 << KIND_SHIFT,
cv::_InputArray::STD_VECTOR_CUDA_GPU_MAT = 13 << KIND_SHIFT,
cv::_InputArray::STD_ARRAY =14 << KIND_SHIFT,
cv::_InputArray::STD_ARRAY_MAT =15 << KIND_SHIFT
} |
| |
| enum | cv::UMatData::MemoryFlag {
cv::UMatData::COPY_ON_MAP =1,
cv::UMatData::HOST_COPY_OBSOLETE =2,
cv::UMatData::DEVICE_COPY_OBSOLETE =4,
cv::UMatData::TEMP_UMAT =8,
cv::UMatData::TEMP_COPIED_UMAT =24,
cv::UMatData::USER_ALLOCATED =32,
cv::UMatData::DEVICE_MEM_MAPPED =64,
cv::UMatData::ASYNC_CLEANUP =128
} |
| |
| enum | cv::Param {
cv::Param::INT =0,
cv::Param::BOOLEAN =1,
cv::Param::REAL =2,
cv::Param::STRING =3,
cv::Param::MAT =4,
cv::Param::MAT_VECTOR =5,
cv::Param::ALGORITHM =6,
cv::Param::FLOAT =7,
cv::Param::UNSIGNED_INT =8,
cv::Param::UINT64 =9,
cv::Param::UCHAR =11,
cv::Param::SCALAR =12
} |
| |
| enum | cv::TermCriteria::Type {
cv::TermCriteria::COUNT =1,
cv::TermCriteria::MAX_ITER =COUNT,
cv::TermCriteria::EPS =2
} |
| |
| enum | cv::UMatUsageFlags {
cv::USAGE_DEFAULT = 0,
cv::USAGE_ALLOCATE_HOST_MEMORY = 1 << 0,
cv::USAGE_ALLOCATE_DEVICE_MEMORY = 1 << 1,
cv::USAGE_ALLOCATE_SHARED_MEMORY = 1 << 2,
cv::__UMAT_USAGE_FLAGS_32BIT = 0x7fffffff
} |
| | Usage flags for allocator. More...
|
| |
|
| template<typename _Tp , int m> |
| static double | cv::determinant (const Matx< _Tp, m, m > &a) |
| |
| template<typename _Tp , typename... A1> |
| static Ptr< _Tp > | cv::makePtr (const A1 &...a1) |
| |
| InputOutputArray | cv::noArray () |
| |
| template<typename _Tp , int m, int n> |
| static double | cv::norm (const Matx< _Tp, m, n > &M) |
| |
| template<typename _Tp , int m, int n> |
| static double | cv::norm (const Matx< _Tp, m, n > &M, int normType) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | cv::normalize (const Vec< _Tp, cn > &v) |
| |
| static String & | cv::operator<< (String &out, Ptr< Formatted > fmtd) |
| |
| static String & | cv::operator<< (String &out, const Mat &mtx) |
| |
| template<typename _Tp > |
| static _InputArray | cv::rawIn (_Tp &v) |
| |
| template<typename _Tp > |
| static _InputOutputArray | cv::rawInOut (_Tp &v) |
| |
| template<typename _Tp > |
| static _OutputArray | cv::rawOut (_Tp &v) |
| |
| static std::string | cv::toLowerCase (const std::string &str) |
| |
| static std::string | cv::toUpperCase (const std::string &str) |
| |
| template<typename _Tp , int m, int n> |
| static double | cv::trace (const Matx< _Tp, m, n > &a) |
| |