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 ()
	Returns an empty InputArray or OutputArray.

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 = std::shared_ptr<_Tp>

#include <opencv2/core/cvstd_wrapper.hpp>

Examples: modules/shape/samples/shape_example.cpp.

◆ 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

Function Documentation

◆ determinant()

template<typename _Tp , int m>

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

inlinestatic

Python:
	cv.determinant(	mtx	) ->	retval

#include <opencv2/core/matx.hpp>

◆ makePtr()

template<typename _Tp , typename ... A1>

static Ptr< _Tp > cv::makePtr ( const A1 &... a1 )

inlinestatic

#include <opencv2/core/cvstd_wrapper.hpp>

◆ noArray()

InputOutputArray cv::noArray ( )

#include <opencv2/core/mat.hpp>

Returns an empty InputArray or OutputArray.

This function is used to provide an "empty" or "null" array when certain functions take optional input or output arrays that you don't want to provide.

Many OpenCV functions accept optional arguments as cv::InputArray or cv::OutputArray. When you don't want to pass any data for these optional parameters, you can use cv::noArray() to indicate that you are omitting them.