Classes
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::Param

struct	cv::ParamType< _Tp >

struct	cv::ParamType< Algorithm >

struct	cv::ParamType< bool >

struct	cv::ParamType< double >

struct	cv::ParamType< float >

struct	cv::ParamType< Mat >

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...

struct	cv::Ptr< T >
	Template class for smart pointers with shared ownership. 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::String

class	cv::TermCriteria
	The class defining termination criteria for iterative algorithms. More...

class	cv::TypeDepth< _depth >

class	cv::TypeDepth< CV_16S >

class	cv::TypeDepth< CV_16U >

class	cv::TypeDepth< CV_32F >

class	cv::TypeDepth< CV_32S >

class	cv::TypeDepth< CV_64F >

class	cv::TypeDepth< CV_8S >

class	cv::TypeDepth< CV_8U >

class	cv::UMat

struct	cv::UMatData

struct	cv::UMatDataAutoLock

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...

Typedefs
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 Point3_< double >	cv::Point3d

typedef Point3_< float >	cv::Point3f

typedef Point3_< int >	cv::Point3i

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

Enumerations
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 >::depth = DataType<_Tp>::depth, 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 >::type = CV_MAKETYPE(depth, channels), cv::Matx< _Tp, m, n >::shortdim = (m < n ? m : n) }

enum	{ cv::Vec< _Tp, cn >::depth = Matx<_Tp, cn, 1>::depth, cv::Vec< _Tp, cn >::channels = cn, cv::Vec< _Tp, cn >::type = CV_MAKETYPE(depth, channels) }

enum	{ 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::DataType< _Tp >::generic_type = 1, cv::DataType< _Tp >::depth = -1, cv::DataType< _Tp >::channels = 1, cv::DataType< _Tp >::fmt = 0, cv::DataType< _Tp >::type = CV_MAKETYPE(depth, channels) }

enum	{ 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 }

enum	{ cv::DataDepth< _Tp >::value = DataType<_Tp>::depth, cv::DataDepth< _Tp >::fmt = DataType<_Tp>::fmt }

enum	{ 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_ALL = (DEPTH_MASK_64F<<1)-1, cv::_OutputArray::DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S, cv::_OutputArray::DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F }

enum	{ 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 }

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::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::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 }

enum	{ cv::ParamType< bool >::type = Param::BOOLEAN }

enum	{ cv::Mat::MAGIC_MASK = 0xFFFF0000, cv::Mat::TYPE_MASK = 0x00000FFF, cv::Mat::DEPTH_MASK = 7 }

enum	{ cv::ParamType< double >::type = Param::REAL }

enum	{ cv::ParamType< String >::type = Param::STRING }

enum	{ cv::ParamType< Mat >::type = Param::MAT }

enum	{ cv::ParamType< std::vector< Mat > >::type = Param::MAT_VECTOR }

enum	{ cv::ParamType< Algorithm >::type = Param::ALGORITHM }

enum	{ cv::ParamType< float >::type = Param::FLOAT }

enum	{ cv::ParamType< unsigned >::type = Param::UNSIGNED_INT }

enum	{ cv::ParamType< uint64 >::type = Param::UINT64 }

enum	{ cv::ParamType< uchar >::type = Param::UCHAR }

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::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...

Functions
template<typename _Tp , int m>
static double	cv::determinant (const Matx< _Tp, m, m > &a)

template<typename T >
Ptr< T >	cv::makePtr ()

template<typename T , typename A1 >
Ptr< T >	cv::makePtr (const A1 &a1)

template<typename T , typename A1 , typename A2 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2)

template<typename T , typename A1 , typename A2 , typename A3 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3)

template<typename T , typename A1 , typename A2 , typename A3 , typename A4 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)

template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)

template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)

template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)

template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)

template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)

template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 >
Ptr< T >	cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10)

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)

template<typename T >
bool	cv::operator!= (const Ptr< T > &ptr1, const Ptr< T > &ptr2)

static String &	cv::operator<< (String &out, Ptr< Formatted > fmtd)

static String &	cv::operator<< (String &out, const Mat &mtx)

template<typename T >
bool	cv::operator== (const Ptr< T > &ptr1, const Ptr< T > &ptr2)

template<typename T >
void	cv::swap (Ptr< T > &ptr1, Ptr< T > &ptr2)

template<typename _Tp , int m, int n>
static double	cv::trace (const Matx< _Tp, m, n > &a)

Shorter aliases for the most popular specializations of Vec<T,n>
typedef Vec< uchar, 2 >	cv::Vec2b

typedef Vec< uchar, 3 >	cv::Vec3b

typedef Vec< uchar, 4 >	cv::Vec4b

typedef Vec< short, 2 >	cv::Vec2s

typedef Vec< short, 3 >	cv::Vec3s

typedef Vec< short, 4 >	cv::Vec4s

typedef Vec< ushort, 2 >	cv::Vec2w

typedef Vec< ushort, 3 >	cv::Vec3w

typedef Vec< ushort, 4 >	cv::Vec4w

typedef Vec< int, 2 >	cv::Vec2i

typedef Vec< int, 3 >	cv::Vec3i

typedef Vec< int, 4 >	cv::Vec4i

typedef Vec< int, 6 >	cv::Vec6i

typedef Vec< int, 8 >	cv::Vec8i

typedef Vec< float, 2 >	cv::Vec2f

typedef Vec< float, 3 >	cv::Vec3f

typedef Vec< float, 4 >	cv::Vec4f

typedef Vec< float, 6 >	cv::Vec6f

typedef Vec< double, 2 >	cv::Vec2d

typedef Vec< double, 3 >	cv::Vec3d

typedef Vec< double, 4 >	cv::Vec4d

typedef Vec< double, 6 >	cv::Vec6d

Detailed Description

Typedef Documentation

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

Examples:: contours2.cpp, demhist.cpp, ffilldemo.cpp, grabcut.cpp, houghcircles.cpp, houghlines.cpp, morphology2.cpp, segment_objects.cpp, and watershed.cpp.

typedef Point_<double> cv::Point2d

typedef Point_<float> cv::Point2f

Examples:: cout_mat.cpp.

typedef Point_<int> cv::Point2i

typedef Point3_<double> cv::Point3d

typedef Point3_<float> cv::Point3f

typedef Point3_<int> cv::Point3i

typedef Rect2i cv::Rect

Examples:: grabcut.cpp.

typedef Rect_<double> cv::Rect2d

typedef Rect_<float> cv::Rect2f

typedef Rect_<int> cv::Rect2i

typedef Scalar_<double> cv::Scalar

Examples:: contours2.cpp, convexhull.cpp, distrans.cpp, ffilldemo.cpp, fitellipse.cpp, grabcut.cpp, houghcircles.cpp, houghlines.cpp, kmeans.cpp, and minarea.cpp.

typedef Size2i cv::Size

Examples:: contours2.cpp, edge.cpp, laplace.cpp, and morphology2.cpp.

typedef Size_<double> cv::Size2d

typedef Size_<float> cv::Size2f

typedef Size_<int> cv::Size2i

typedef Vec<uchar, 2> cv::Vec2b

typedef Vec<double, 2> cv::Vec2d

typedef Vec<float, 2> cv::Vec2f

typedef Vec<int, 2> cv::Vec2i

typedef Vec<short, 2> cv::Vec2s

typedef Vec<ushort, 2> cv::Vec2w

typedef Vec<uchar, 3> cv::Vec3b

Examples:: watershed.cpp.

typedef Vec<double, 3> cv::Vec3d

typedef Vec<float, 3> cv::Vec3f

typedef Vec<int, 3> cv::Vec3i

typedef Vec<short, 3> cv::Vec3s

typedef Vec<ushort, 3> cv::Vec3w

typedef Vec<uchar, 4> cv::Vec4b

typedef Vec<double, 4> cv::Vec4d

typedef Vec<float, 4> cv::Vec4f

typedef Vec<int, 4> cv::Vec4i

typedef Vec<short, 4> cv::Vec4s

typedef Vec<ushort, 4> cv::Vec4w

typedef Vec<double, 6> cv::Vec6d

typedef Vec<float, 6> cv::Vec6f

typedef Vec<int, 6> cv::Vec6i

typedef Vec<int, 8> cv::Vec8i

Enumeration Type Documentation

anonymous enum

Enumerator
MAGIC_VAL
MAX_DIM
HASH_SCALE
HASH_BIT

template<typename _Tp, int m, int n>

anonymous enum

Enumerator
depth
rows
cols
channels
type
shortdim

template<typename _Tp, int cn>

anonymous enum

Enumerator
depth
channels
type

anonymous enum

Enumerator
ACCESS_READ
ACCESS_WRITE
ACCESS_RW
ACCESS_MASK
ACCESS_FAST

template<typename _Tp>

anonymous enum

Enumerator
generic_type
depth
channels
fmt
type

anonymous enum

Enumerator
KIND_SHIFT
FIXED_TYPE
FIXED_SIZE
KIND_MASK
NONE
MAT
MATX
STD_VECTOR
STD_VECTOR_VECTOR
STD_VECTOR_MAT
EXPR
OPENGL_BUFFER
CUDA_HOST_MEM
CUDA_GPU_MAT
UMAT
STD_VECTOR_UMAT
STD_BOOL_VECTOR
STD_VECTOR_CUDA_GPU_MAT

template<typename _Tp >

anonymous enum

Enumerator
value
fmt

anonymous enum

Enumerator
DEPTH_MASK_8U
DEPTH_MASK_8S
DEPTH_MASK_16U
DEPTH_MASK_16S
DEPTH_MASK_32S
DEPTH_MASK_32F
DEPTH_MASK_64F
DEPTH_MASK_ALL
DEPTH_MASK_ALL_BUT_8S
DEPTH_MASK_FLT

anonymous enum

Enumerator
COPY_ON_MAP
HOST_COPY_OBSOLETE
DEVICE_COPY_OBSOLETE
TEMP_UMAT
TEMP_COPIED_UMAT
USER_ALLOCATED
DEVICE_MEM_MAPPED

anonymous enum

Enumerator
MAGIC_VAL
AUTO_STEP
CONTINUOUS_FLAG
SUBMATRIX_FLAG

anonymous enum

Enumerator
FMT_DEFAULT
FMT_MATLAB
FMT_CSV
FMT_PYTHON
FMT_NUMPY
FMT_C

anonymous enum

Enumerator
INT
BOOLEAN
REAL
STRING
MAT
MAT_VECTOR
ALGORITHM
FLOAT
UNSIGNED_INT
UINT64
UCHAR

anonymous enum

Enumerator
type

anonymous enum

Enumerator
MAGIC_MASK
TYPE_MASK
DEPTH_MASK

anonymous enum

Enumerator
type

anonymous enum

Enumerator
type

anonymous enum

Enumerator
type

anonymous enum

Enumerator
type

anonymous enum

Enumerator
type

anonymous enum

Enumerator
type

anonymous enum

Enumerator
type

anonymous enum

Enumerator
type

anonymous enum

Enumerator
type

anonymous enum

Enumerator
MAGIC_VAL
AUTO_STEP
CONTINUOUS_FLAG
SUBMATRIX_FLAG

anonymous enum

Enumerator
MAGIC_MASK
TYPE_MASK
DEPTH_MASK

enum cv::TermCriteria::Type

Criteria type, can be one of: COUNT, EPS or COUNT + EPS

Enumerator
COUNT	the maximum number of iterations or elements to compute
MAX_ITER	ditto
EPS	the desired accuracy or change in parameters at which the iterative algorithm stops

enum cv::UMatUsageFlags

Usage flags for allocator.

Enumerator
USAGE_DEFAULT
USAGE_ALLOCATE_HOST_MEMORY
USAGE_ALLOCATE_DEVICE_MEMORY
USAGE_ALLOCATE_SHARED_MEMORY
__UMAT_USAGE_FLAGS_32BIT

Function Documentation

template<typename _Tp , int m>

static double cv::determinant ( const Matx< _Tp, m, m > & a )

static

template<typename T >

Ptr<T> cv::makePtr ( )

makePtr<T>(...) is equivalent to Ptr<T>(new T(...)). It is shorter than the latter, and it's marginally safer than using a constructor or Ptr::reset, since it ensures that the owned pointer is new and thus not owned by any other Ptr instance. Unfortunately, perfect forwarding is impossible to implement in C++03, and so makePtr is limited to constructors of T that have up to 10 arguments, none of which are non-const references.

template<typename T , typename A1 >

Ptr<T> cv::makePtr ( const A1 & a1 )