Detailed Description

Namespaces
namespace	cv::traits

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

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 This is a list of implemented matrix operations that can be combined in arbitrary complex expressions (here A, B stand for matrices ( Mat ), s for a scalar ( Scalar ), alpha for a real-valued scalar ( double )): 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::NAryMatIterator
	n-ary multi-dimensional array iterator. 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...

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

Enumerations
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 struct	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::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 _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>
Vec< _Tp, cn >	cv::normalize (const Vec< _Tp, cn > &v)

template<typename _Tp , int m, int n>
static bool	cv::operator!= (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)

template<typename _Tp , int m, int n, int l>
static Matx< _Tp, m, n >	cv::operator* (const Matx< _Tp, m, l > &a, const Matx< _Tp, l, n > &b)

template<typename _Tp , int m, int n>
static Vec< _Tp, m >	cv::operator* (const Matx< _Tp, m, n > &a, const Vec< _Tp, n > &b)

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

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (const Matx< _Tp, m, n > &a, float alpha)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (const Matx< _Tp, m, n > &a, int alpha)

template<typename _Tp >
Vec< _Tp, 4 >	cv::operator* (const Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (const Vec< _Tp, cn > &a, double alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (const Vec< _Tp, cn > &a, float alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (const Vec< _Tp, cn > &a, int alpha)

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

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (double alpha, const Vec< _Tp, cn > &a)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (float alpha, const Matx< _Tp, m, n > &a)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (float alpha, const Vec< _Tp, cn > &a)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (int alpha, const Matx< _Tp, m, n > &a)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (int alpha, const Vec< _Tp, cn > &a)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator*= (Matx< _Tp, m, n > &a, double alpha)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator*= (Matx< _Tp, m, n > &a, float alpha)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator*= (Matx< _Tp, m, n > &a, int alpha)

template<typename _Tp >
Vec< _Tp, 4 > &	cv::operator*= (Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2)

template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator*= (Vec< _Tp, cn > &a, double alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator*= (Vec< _Tp, cn > &a, float alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator*= (Vec< _Tp, cn > &a, int alpha)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator+ (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator+ (const Vec< _Tp, cn > &a, const Vec< _Tp, cn > &b)

template<typename _Tp1 , typename _Tp2 , int m, int n>
static Matx< _Tp1, m, n > &	cv::operator+= (Matx< _Tp1, m, n > &a, const Matx< _Tp2, m, n > &b)

template<typename _Tp1 , typename _Tp2 , int cn>
static Vec< _Tp1, cn > &	cv::operator+= (Vec< _Tp1, cn > &a, const Vec< _Tp2, cn > &b)

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

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator- (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator- (const Vec< _Tp, cn > &a)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator- (const Vec< _Tp, cn > &a, const Vec< _Tp, cn > &b)

template<typename _Tp1 , typename _Tp2 , int m, int n>
static Matx< _Tp1, m, n > &	cv::operator-= (Matx< _Tp1, m, n > &a, const Matx< _Tp2, m, n > &b)

template<typename _Tp1 , typename _Tp2 , int cn>
static Vec< _Tp1, cn > &	cv::operator-= (Vec< _Tp1, cn > &a, const Vec< _Tp2, cn > &b)

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

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator/ (const Matx< _Tp, m, n > &a, float alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator/ (const Vec< _Tp, cn > &a, double alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator/ (const Vec< _Tp, cn > &a, float alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator/ (const Vec< _Tp, cn > &a, int alpha)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator/= (Matx< _Tp, m, n > &a, double alpha)

template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator/= (Matx< _Tp, m, n > &a, float alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator/= (Vec< _Tp, cn > &a, double alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator/= (Vec< _Tp, cn > &a, float alpha)

template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator/= (Vec< _Tp, cn > &a, int alpha)

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

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

template<typename _Tp , int m, int n>
static bool	cv::operator== (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)

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)

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

Typedef Documentation

◆ Complexd

typedef Complex<double> cv::Complexd

#include <opencv2/core/types.hpp>

◆ Complexf

typedef Complex<float> cv::Complexf

#include <opencv2/core/types.hpp>

◆ InputArray

typedef const _InputArray& cv::InputArray

#include <opencv2/core/mat.hpp>

◆ InputArrayOfArrays

typedef InputArray cv::InputArrayOfArrays

#include <opencv2/core/mat.hpp>

◆ InputOutputArray

typedef const _InputOutputArray& cv::InputOutputArray

#include <opencv2/core/mat.hpp>

◆ InputOutputArrayOfArrays

typedef InputOutputArray cv::InputOutputArrayOfArrays

#include <opencv2/core/mat.hpp>

◆ Mat1b

typedef Mat_<uchar> cv::Mat1b

#include <opencv2/core/mat.hpp>

◆ Mat1d

typedef Mat_<double> cv::Mat1d

#include <opencv2/core/mat.hpp>

◆ Mat1f

typedef Mat_<float> cv::Mat1f

#include <opencv2/core/mat.hpp>

◆ Mat1i

typedef Mat_<int> cv::Mat1i

#include <opencv2/core/mat.hpp>

◆ Mat1s

typedef Mat_<short> cv::Mat1s

#include <opencv2/core/mat.hpp>

◆ Mat1w

typedef Mat_<ushort> cv::Mat1w

#include <opencv2/core/mat.hpp>

◆ Mat2b

typedef Mat_<Vec2b> cv::Mat2b

#include <opencv2/core/mat.hpp>

◆ Mat2d

typedef Mat_<Vec2d> cv::Mat2d

#include <opencv2/core/mat.hpp>

◆ Mat2f

typedef Mat_<Vec2f> cv::Mat2f

#include <opencv2/core/mat.hpp>

◆ Mat2i

typedef Mat_<Vec2i> cv::Mat2i

#include <opencv2/core/mat.hpp>

◆ Mat2s

typedef Mat_<Vec2s> cv::Mat2s

#include <opencv2/core/mat.hpp>

◆ Mat2w

typedef Mat_<Vec2w> cv::Mat2w

#include <opencv2/core/mat.hpp>

◆ Mat3b

typedef Mat_<Vec3b> cv::Mat3b

#include <opencv2/core/mat.hpp>

◆ Mat3d

typedef Mat_<Vec3d> cv::Mat3d

#include <opencv2/core/mat.hpp>

◆ Mat3f

typedef Mat_<Vec3f> cv::Mat3f

#include <opencv2/core/mat.hpp>

◆ Mat3i

typedef Mat_<Vec3i> cv::Mat3i

#include <opencv2/core/mat.hpp>

◆ Mat3s

typedef Mat_<Vec3s> cv::Mat3s

#include <opencv2/core/mat.hpp>

◆ Mat3w

typedef Mat_<Vec3w> cv::Mat3w

#include <opencv2/core/mat.hpp>

◆ Mat4b

typedef Mat_<Vec4b> cv::Mat4b

#include <opencv2/core/mat.hpp>

◆ Mat4d

typedef Mat_<Vec4d> cv::Mat4d

#include <opencv2/core/mat.hpp>

◆ Mat4f

typedef Mat_<Vec4f> cv::Mat4f

#include <opencv2/core/mat.hpp>

◆ Mat4i

typedef Mat_<Vec4i> cv::Mat4i

#include <opencv2/core/mat.hpp>

◆ Mat4s

typedef Mat_<Vec4s> cv::Mat4s

#include <opencv2/core/mat.hpp>

◆ Mat4w

typedef Mat_<Vec4w> cv::Mat4w

#include <opencv2/core/mat.hpp>

◆ Matx12d

typedef Matx<double, 1, 2> cv::Matx12d

#include <opencv2/core/matx.hpp>

◆ Matx12f

typedef Matx<float, 1, 2> cv::Matx12f

#include <opencv2/core/matx.hpp>

◆ Matx13d

typedef Matx<double, 1, 3> cv::Matx13d

#include <opencv2/core/matx.hpp>

◆ Matx13f

typedef Matx<float, 1, 3> cv::Matx13f

#include <opencv2/core/matx.hpp>

◆ Matx14d

typedef Matx<double, 1, 4> cv::Matx14d

#include <opencv2/core/matx.hpp>

◆ Matx14f

typedef Matx<float, 1, 4> cv::Matx14f

#include <opencv2/core/matx.hpp>

◆ Matx16d

typedef Matx<double, 1, 6> cv::Matx16d

#include <opencv2/core/matx.hpp>

◆ Matx16f

typedef Matx<float, 1, 6> cv::Matx16f

#include <opencv2/core/matx.hpp>

◆ Matx21d

typedef Matx<double, 2, 1> cv::Matx21d

#include <opencv2/core/matx.hpp>

◆ Matx21f

typedef Matx<float, 2, 1> cv::Matx21f

#include <opencv2/core/matx.hpp>

◆ Matx22d

typedef Matx<double, 2, 2> cv::Matx22d

#include <opencv2/core/matx.hpp>

◆ Matx22f

typedef Matx<float, 2, 2> cv::Matx22f

#include <opencv2/core/matx.hpp>

◆ Matx23d

typedef Matx<double, 2, 3> cv::Matx23d

#include <opencv2/core/matx.hpp>

◆ Matx23f

typedef Matx<float, 2, 3> cv::Matx23f

#include <opencv2/core/matx.hpp>

◆ Matx31d

typedef Matx<double, 3, 1> cv::Matx31d

#include <opencv2/core/matx.hpp>

◆ Matx31f

typedef Matx<float, 3, 1> cv::Matx31f

#include <opencv2/core/matx.hpp>

◆ Matx32d

typedef Matx<double, 3, 2> cv::Matx32d

#include <opencv2/core/matx.hpp>

◆ Matx32f

typedef Matx<float, 3, 2> cv::Matx32f

#include <opencv2/core/matx.hpp>

◆ Matx33d

typedef Matx<double, 3, 3> cv::Matx33d

#include <opencv2/core/matx.hpp>

◆ Matx33f

typedef Matx<float, 3, 3> cv::Matx33f

#include <opencv2/core/matx.hpp>

◆ Matx34d

typedef Matx<double, 3, 4> cv::Matx34d

#include <opencv2/core/matx.hpp>

◆ Matx34f

typedef Matx<float, 3, 4> cv::Matx34f

#include <opencv2/core/matx.hpp>

◆ Matx41d

typedef Matx<double, 4, 1> cv::Matx41d

#include <opencv2/core/matx.hpp>

◆ Matx41f

typedef Matx<float, 4, 1> cv::Matx41f

#include <opencv2/core/matx.hpp>

◆ Matx43d

typedef Matx<double, 4, 3> cv::Matx43d

#include <opencv2/core/matx.hpp>

◆ Matx43f

typedef Matx<float, 4, 3> cv::Matx43f

#include <opencv2/core/matx.hpp>

◆ Matx44d

typedef Matx<double, 4, 4> cv::Matx44d

#include <opencv2/core/matx.hpp>

◆ Matx44f

typedef Matx<float, 4, 4> cv::Matx44f

#include <opencv2/core/matx.hpp>

◆ Matx61d

typedef Matx<double, 6, 1> cv::Matx61d

#include <opencv2/core/matx.hpp>

◆ Matx61f

typedef Matx<float, 6, 1> cv::Matx61f

#include <opencv2/core/matx.hpp>

◆ Matx66d

typedef Matx<double, 6, 6> cv::Matx66d

#include <opencv2/core/matx.hpp>

◆ Matx66f

typedef Matx<float, 6, 6> cv::Matx66f

#include <opencv2/core/matx.hpp>

◆ OutputArray

typedef const _OutputArray& cv::OutputArray

#include <opencv2/core/mat.hpp>

◆ OutputArrayOfArrays

typedef OutputArray cv::OutputArrayOfArrays

#include <opencv2/core/mat.hpp>

◆ Point

typedef Point2i cv::Point

#include <opencv2/core/types.hpp>

Examples: samples/cpp/fitellipse.cpp.

◆ Point2d

typedef Point_<double> cv::Point2d

#include <opencv2/core/types.hpp>

◆ Point2f

typedef Point_<float> cv::Point2f

#include <opencv2/core/types.hpp>

Examples: samples/cpp/fitellipse.cpp.

◆ Point2i

typedef Point_<int> cv::Point2i

#include <opencv2/core/types.hpp>

◆ Point2l

typedef Point_<int64> cv::Point2l

#include <opencv2/core/types.hpp>

◆ Point3d

typedef Point3_<double> cv::Point3d

#include <opencv2/core/types.hpp>

◆ Point3f

typedef Point3_<float> cv::Point3f

#include <opencv2/core/types.hpp>

◆ Point3i

typedef Point3_<int> cv::Point3i

#include <opencv2/core/types.hpp>

◆ Ptr

template<typename _Tp >

using cv::Ptr = typedef std::shared_ptr<_Tp>

#include <opencv2/core/cvstd_wrapper.hpp>

◆ Rect

typedef Rect2i cv::Rect

#include <opencv2/core/types.hpp>

◆ Rect2d

typedef Rect_<double> cv::Rect2d

#include <opencv2/core/types.hpp>

◆ Rect2f

typedef Rect_<float> cv::Rect2f

#include <opencv2/core/types.hpp>

◆ Rect2i

typedef Rect_<int> cv::Rect2i

#include <opencv2/core/types.hpp>

◆ Scalar

typedef Scalar_<double> cv::Scalar

#include <opencv2/core/types.hpp>

◆ Size

typedef Size2i cv::Size

#include <opencv2/core/types.hpp>

◆ Size2d

typedef Size_<double> cv::Size2d

#include <opencv2/core/types.hpp>

◆ Size2f

typedef Size_<float> cv::Size2f

#include <opencv2/core/types.hpp>

◆ Size2i

typedef Size_<int> cv::Size2i

#include <opencv2/core/types.hpp>

◆ Size2l

typedef Size_<int64> cv::Size2l

#include <opencv2/core/types.hpp>

◆ String

typedef std::string cv::String

#include <opencv2/core/cvstd.hpp>

◆ Vec2b

typedef Vec<uchar, 2> cv::Vec2b

#include <opencv2/core/matx.hpp>

◆ Vec2d

typedef Vec<double, 2> cv::Vec2d

#include <opencv2/core/matx.hpp>

◆ Vec2f

typedef Vec<float, 2> cv::Vec2f

#include <opencv2/core/matx.hpp>

◆ Vec2i

typedef Vec<int, 2> cv::Vec2i

#include <opencv2/core/matx.hpp>

◆ Vec2s

typedef Vec<short, 2> cv::Vec2s

#include <opencv2/core/matx.hpp>

◆ Vec2w

typedef Vec<ushort, 2> cv::Vec2w

#include <opencv2/core/matx.hpp>

◆ Vec3b

typedef Vec<uchar, 3> cv::Vec3b

#include <opencv2/core/matx.hpp>

◆ Vec3d

typedef Vec<double, 3> cv::Vec3d

#include <opencv2/core/matx.hpp>

◆ Vec3f

typedef Vec<float, 3> cv::Vec3f

#include <opencv2/core/matx.hpp>

◆ Vec3i

typedef Vec<int, 3> cv::Vec3i

#include <opencv2/core/matx.hpp>

◆ Vec3s

typedef Vec<short, 3> cv::Vec3s

#include <opencv2/core/matx.hpp>

◆ Vec3w

typedef Vec<ushort, 3> cv::Vec3w

#include <opencv2/core/matx.hpp>

◆ Vec4b

typedef Vec<uchar, 4> cv::Vec4b

#include <opencv2/core/matx.hpp>

◆ Vec4d

typedef Vec<double, 4> cv::Vec4d

#include <opencv2/core/matx.hpp>

◆ Vec4f

typedef Vec<float, 4> cv::Vec4f

#include <opencv2/core/matx.hpp>

◆ Vec4i

typedef Vec<int, 4> cv::Vec4i

#include <opencv2/core/matx.hpp>

◆ Vec4s

typedef Vec<short, 4> cv::Vec4s

#include <opencv2/core/matx.hpp>

◆ Vec4w

typedef Vec<ushort, 4> cv::Vec4w

#include <opencv2/core/matx.hpp>

◆ Vec6d

typedef Vec<double, 6> cv::Vec6d

#include <opencv2/core/matx.hpp>

◆ Vec6f

typedef Vec<float, 6> cv::Vec6f

#include <opencv2/core/matx.hpp>

◆ Vec6i

typedef Vec<int, 6> cv::Vec6i

#include <opencv2/core/matx.hpp>

◆ Vec8i

typedef Vec<int, 8> cv::Vec8i

#include <opencv2/core/matx.hpp>

Enumeration Type Documentation

◆ AccessFlag

enum cv::AccessFlag

#include <opencv2/core/mat.hpp>

Enumerator
ACCESS_READ Python: cv.ACCESS_READ
ACCESS_WRITE Python: cv.ACCESS_WRITE
ACCESS_RW Python: cv.ACCESS_RW
ACCESS_MASK Python: cv.ACCESS_MASK
ACCESS_FAST Python: cv.ACCESS_FAST

◆ Param

enum struct cv::Param

strong

#include <opencv2/core.hpp>

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

◆ UMatUsageFlags

enum cv::UMatUsageFlags

#include <opencv2/core/mat.hpp>

Usage flags for allocator.

Warning: All flags except USAGE_DEFAULT are experimental.; For the OpenCL allocator, USAGE_ALLOCATE_SHARED_MEMORY depends on OpenCV's optional, experimental integration with OpenCL SVM. To enable this integration, build OpenCV using the WITH_OPENCL_SVM=ON CMake option and, at runtime, call cv::ocl::Context::getDefault().setUseSVM(true); or similar code. Note that SVM is incompatible with OpenCL 1.x.

Enumerator
USAGE_DEFAULT Python: cv.USAGE_DEFAULT
USAGE_ALLOCATE_HOST_MEMORY Python: cv.USAGE_ALLOCATE_HOST_MEMORY
USAGE_ALLOCATE_DEVICE_MEMORY Python: cv.USAGE_ALLOCATE_DEVICE_MEMORY
USAGE_ALLOCATE_SHARED_MEMORY Python: cv.USAGE_ALLOCATE_SHARED_MEMORY
__UMAT_USAGE_FLAGS_32BIT Python: cv.__UMAT_USAGE_FLAGS_32BIT