OpenCV  3.1.0
Open Source Computer Vision
Classes | Typedefs | Enumerations | Functions
Basic structures

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_< ucharcv::Mat1b
 
typedef Mat_< double > cv::Mat1d
 
typedef Mat_< float > cv::Mat1f
 
typedef Mat_< int > cv::Mat1i
 
typedef Mat_< short > cv::Mat1s
 
typedef Mat_< ushortcv::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
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
typedef Size2i cv::Size
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 

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

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)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

InputOutputArray cv::noArray ( )
template<typename _Tp , int m, int n>
static double cv::norm ( const Matx< _Tp, m, n > &  M)
static
template<typename _Tp , int m, int n>
static double cv::norm ( const Matx< _Tp, m, n > &  M,
int  normType 
)
static
template<typename _Tp , int cn>
static Vec<_Tp, cn> cv::normalize ( const Vec< _Tp, cn > &  v)
static
Examples:
demhist.cpp, and pca.cpp.
template<typename T >
bool cv::operator!= ( const Ptr< T > &  ptr1,
const Ptr< T > &  ptr2 
)
static String& cv::operator<< ( String out,
Ptr< Formatted fmtd 
)
inlinestatic
static String& cv::operator<< ( String out,
const Mat mtx 
)
inlinestatic
template<typename T >
bool cv::operator== ( const Ptr< T > &  ptr1,
const Ptr< T > &  ptr2 
)

Return whether ptr1.get() and ptr2.get() are equal and not equal, respectively.

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

Equivalent to ptr1.swap(ptr2). Provided to help write generic algorithms.

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