Basic structures#

Detailed Description#

Namespaces#

cv::traits namespace

Classes#

Name	Description
`class` `cv::_InputArray`	This is the proxy class for passing read-only input arrays into OpenCV functions. View details
`class` `cv::_InputOutputArray`	View details
`class` `cv::_OutputArray`	This type is very similar to InputArray except that it is used for input/output and output function parameters. View details
`class` `cv::Algorithm`	This is a base class for all more or less complex algorithms in OpenCV. View details
`class` `cv::Complex< _Tp >`	A complex number class. View details
`class` `cv::DataDepth< _Tp >`	A helper class for cv::DataType. View details
`class` `cv::DataType< _Tp >`	Template “trait” class for OpenCV primitive data types. View details
`class` `cv::DMatch`	Class for matching keypoint descriptors. View details
`class` `cv::Formatted`	View details
`class` `cv::Formatter`	View details
`class` `cv::KeyPoint`	Data structure for salient point detectors. View details
`class` `cv::Mat`	Comma-separated Matrix Initializer. View details
`class` `cv::Mat_< _Tp >`	Template matrix class derived from Mat. View details
`class` `cv::MatAllocator`	Custom array allocator. View details
`class` `cv::MatConstIterator`	View details
`class` `cv::MatConstIterator_< _Tp >`	Matrix read-only iterator. View details
`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 ( cv::Mat ), s for a cv::Scalar, alpha for a real-valued scalar ( double )): View details
`class` `cv::MatIterator_< _Tp >`	Matrix read-write iterator. View details
`class` `cv::MatOp`	View details
`struct` `cv::MatShape`	Represents shape of a matrix/tensor. Previously, MatShape was defined as an alias of std::vector, but now we use a special structure that provides a few extra benefits: View details
`class` `cv::Matx< _Tp, m, n >`	Template class for small matrices whose type and size are known at compilation time. View details
`class` `cv::NAryMatIterator`	n-ary multi-dimensional array iterator. View details
`struct` `cv::ParamType`	View details
`struct` `cv::ParamType< _Tp, typename std::enable_if< std::is_enum< _Tp >::value >::type >`	View details
`struct` `cv::ParamType< Algorithm >`	View details
`struct` `cv::ParamType< bool >`	View details
`struct` `cv::ParamType< double >`	View details
`struct` `cv::ParamType< float >`	View details
`struct` `cv::ParamType< Mat >`	View details
`struct` `cv::ParamType< Scalar >`	View details
`struct` `cv::ParamType< std::vector< Mat > >`	View details
`struct` `cv::ParamType< String >`	View details
`struct` `cv::ParamType< uchar >`	View details
`struct` `cv::ParamType< uint64 >`	View details
`struct` `cv::ParamType< unsigned >`	View details
`class` `cv::Point3_< _Tp >`	Template class for 3D points specified by its coordinates x, y and z. View details
`class` `cv::Point_< _Tp >`	Template class for 2D points specified by its coordinates x and y. View details
`class` `cv::Range`	Template class specifying a continuous subsequence (slice) of a sequence. View details
`class` `cv::Rect_< _Tp >`	Template class for 2D rectangles. View details
`class` `cv::RotatedRect`	The class represents rotated (i.e. not up-right) rectangles on a plane. View details
`class` `cv::Scalar_< _Tp >`	Template class for a 4-element vector derived from Vec. View details
`class` `cv::Size_< _Tp >`	Template class for specifying the size of an image or rectangle. View details
`class` `cv::SparseMat`	The class SparseMat represents multi-dimensional sparse numerical arrays. View details
`class` `cv::SparseMat_< _Tp >`	Template sparse n-dimensional array class derived from SparseMat. View details
`class` `cv::SparseMatConstIterator`	Read-Only Sparse Matrix Iterator. View details
`class` `cv::SparseMatConstIterator_< _Tp >`	Template Read-Only Sparse Matrix Iterator Class. View details
`class` `cv::SparseMatIterator`	Read-write Sparse Matrix Iterator. View details
`class` `cv::SparseMatIterator_< _Tp >`	Template Read-Write Sparse Matrix Iterator Class. View details
`class` `cv::TermCriteria`	The class defining termination criteria for iterative algorithms. View details
`class` `cv::UMat`	View details
`class` `cv::Vec< _Tp, cn >`	Template class for short numerical vectors, a partial case of Matx. View details

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
}

View details

enum cv::DataLayout {
    cv::DATA_LAYOUT_UNKNOWN = 0,
    cv::DATA_LAYOUT_ND = 1,
    cv::DATA_LAYOUT_NCHW = 2,
    cv::DATA_LAYOUT_NCDHW = 3,
    cv::DATA_LAYOUT_NHWC = 4,
    cv::DATA_LAYOUT_NDHWC = 5,
    cv::DATA_LAYOUT_PLANAR = 6,
    cv::DATA_LAYOUT_BLOCK = 7,
    cv::DNN_LAYOUT_UNKNOWN = 0,
    cv::DNN_LAYOUT_ND = 1,
    cv::DNN_LAYOUT_NCHW = 2,
    cv::DNN_LAYOUT_NCDHW = 3,
    cv::DNN_LAYOUT_NHWC = 4,
    cv::DNN_LAYOUT_NDHWC = 5,
    cv::DNN_LAYOUT_PLANAR = 6,
    cv::DNN_LAYOUT_BLOCK = 7
}

Enum of data layout for model inference. View details

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
}

View details

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

Shorter aliases for the most popular specializations of Vec<T,n>#

Type	Name	Description
`Vec< uchar, 2 >`	`cv::Vec2b`
`Vec< uchar, 3 >`	`cv::Vec3b`
`Vec< uchar, 4 >`	`cv::Vec4b`
`Vec< short, 2 >`	`cv::Vec2s`
`Vec< short, 3 >`	`cv::Vec3s`
`Vec< short, 4 >`	`cv::Vec4s`
`Vec< ushort, 2 >`	`cv::Vec2w`
`Vec< ushort, 3 >`	`cv::Vec3w`
`Vec< ushort, 4 >`	`cv::Vec4w`
`Vec< int, 2 >`	`cv::Vec2i`
`Vec< int, 3 >`	`cv::Vec3i`
`Vec< int, 4 >`	`cv::Vec4i`
`Vec< int, 6 >`	`cv::Vec6i`
`Vec< int, 8 >`	`cv::Vec8i`
`Vec< int64_t, 2 >`	`cv::Vec2l`
`Vec< int64_t, 3 >`	`cv::Vec3l`
`Vec< int64_t, 4 >`	`cv::Vec4l`
`Vec< int64_t, 6 >`	`cv::Vec6l`
`Vec< int64_t, 8 >`	`cv::Vec8l`
`Vec< float, 2 >`	`cv::Vec2f`
`Vec< float, 3 >`	`cv::Vec3f`
`Vec< float, 4 >`	`cv::Vec4f`
`Vec< float, 6 >`	`cv::Vec6f`
`Vec< double, 2 >`	`cv::Vec2d`
`Vec< double, 3 >`	`cv::Vec3d`
`Vec< double, 4 >`	`cv::Vec4d`
`Vec< double, 6 >`	`cv::Vec6d`

Typedef Documentation#

Vec2b#

typedef Vec< uchar, 2 > cv::Vec2b

#include <opencv2/core/matx.hpp>

Vec3b#

typedef Vec< uchar, 3 > cv::Vec3b

#include <opencv2/core/matx.hpp>

Vec4b#

typedef Vec< uchar, 4 > cv::Vec4b

#include <opencv2/core/matx.hpp>

Vec2s#

typedef Vec< short, 2 > cv::Vec2s

#include <opencv2/core/matx.hpp>

Vec3s#

typedef Vec< short, 3 > cv::Vec3s

#include <opencv2/core/matx.hpp>

Vec4s#

typedef Vec< short, 4 > cv::Vec4s

#include <opencv2/core/matx.hpp>

Vec2i#

typedef Vec< int, 2 > cv::Vec2i

#include <opencv2/core/matx.hpp>

Vec3i#

typedef Vec< int, 3 > cv::Vec3i

#include <opencv2/core/matx.hpp>

Vec4i#

typedef Vec< int, 4 > cv::Vec4i

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

Vec2l#

typedef Vec< int64_t, 2 > cv::Vec2l

#include <opencv2/core/matx.hpp>

Vec3l#

typedef Vec< int64_t, 3 > cv::Vec3l

#include <opencv2/core/matx.hpp>

Vec4l#

typedef Vec< int64_t, 4 > cv::Vec4l

#include <opencv2/core/matx.hpp>

Vec6l#

typedef Vec< int64_t, 6 > cv::Vec6l

#include <opencv2/core/matx.hpp>

Vec8l#

typedef Vec< int64_t, 8 > cv::Vec8l

#include <opencv2/core/matx.hpp>

Vec2f#

typedef Vec< float, 2 > cv::Vec2f

#include <opencv2/core/matx.hpp>

Vec3f#

typedef Vec< float, 3 > cv::Vec3f

#include <opencv2/core/matx.hpp>

Vec4f#

typedef Vec< float, 4 > cv::Vec4f

#include <opencv2/core/matx.hpp>

Vec6f#

typedef Vec< float, 6 > cv::Vec6f

#include <opencv2/core/matx.hpp>

Vec2d#

typedef Vec< double, 2 > cv::Vec2d

#include <opencv2/core/matx.hpp>

Vec3d#

typedef Vec< double, 3 > cv::Vec3d

#include <opencv2/core/matx.hpp>

Vec4d#

typedef Vec< double, 4 > cv::Vec4d

#include <opencv2/core/matx.hpp>

Vec6d#

typedef Vec< double, 6 > cv::Vec6d

#include <opencv2/core/matx.hpp>

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>

Point2d#

typedef Point_< double > cv::Point2d

#include <opencv2/core/types.hpp>

Point2f#

typedef Point_< float > cv::Point2f

#include <opencv2/core/types.hpp>

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>
typedef std::shared_ptr< _Tp > cv::Ptr

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

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

DataLayout#

enum cv::DataLayout

#include <opencv2/core/mat.hpp>

Enum of data layout for model inference.

See also

Image2BlobParams

Enumerator:

`DATA_LAYOUT_UNKNOWN` Python: `cv.DATA_LAYOUT_UNKNOWN`
`DATA_LAYOUT_ND` Python: `cv.DATA_LAYOUT_ND`	OpenCV data layout for 2D data.
`DATA_LAYOUT_NCHW` Python: `cv.DATA_LAYOUT_NCHW`	OpenCV data layout for 4D data.
`DATA_LAYOUT_NCDHW` Python: `cv.DATA_LAYOUT_NCDHW`	OpenCV data layout for 5D data.
`DATA_LAYOUT_NHWC` Python: `cv.DATA_LAYOUT_NHWC`	Tensorflow-like data layout for 4D data.
`DATA_LAYOUT_NDHWC` Python: `cv.DATA_LAYOUT_NDHWC`	Tensorflow-like data layout for 5D data.
`DATA_LAYOUT_PLANAR` Python: `cv.DATA_LAYOUT_PLANAR`	Tensorflow-like data layout, it should only be used at tf or tflite model parsing.
`DATA_LAYOUT_BLOCK` Python: `cv.DATA_LAYOUT_BLOCK`	Block layout (also referred to as ‘NC1HWC0’), which some accelerators need and even on CPU a better performance may be achieved.
`DNN_LAYOUT_UNKNOWN` Python: `cv.DNN_LAYOUT_UNKNOWN`
`DNN_LAYOUT_ND` Python: `cv.DNN_LAYOUT_ND`	OpenCV data layout for 2D data.
`DNN_LAYOUT_NCHW` Python: `cv.DNN_LAYOUT_NCHW`	OpenCV data layout for 4D data.
`DNN_LAYOUT_NCDHW` Python: `cv.DNN_LAYOUT_NCDHW`	OpenCV data layout for 5D data.
`DNN_LAYOUT_NHWC` Python: `cv.DNN_LAYOUT_NHWC`	Tensorflow-like data layout for 4D data.
`DNN_LAYOUT_NDHWC` Python: `cv.DNN_LAYOUT_NDHWC`	Tensorflow-like data layout for 5D data.
`DNN_LAYOUT_PLANAR` Python: `cv.DNN_LAYOUT_PLANAR`	Tensorflow-like data layout, it should only be used at tf or tflite model parsing.
`DNN_LAYOUT_BLOCK` Python: `cv.DNN_LAYOUT_BLOCK`	Block layout (also referred to as ‘NC1HWC0’), which some accelerators need and even on CPU a better performance may be achieved.

Param#

enum class cv::Param

#include <opencv2/core.hpp>

Enumerator:

INT
Python: cv.Param_INT

BOOLEAN
Python: cv.Param_BOOLEAN

REAL
Python: cv.Param_REAL

STRING
Python: cv.Param_STRING

MAT
Python: cv.Param_MAT

MAT_VECTOR
Python: cv.Param_MAT_VECTOR

ALGORITHM
Python: cv.Param_ALGORITHM

FLOAT
Python: cv.Param_FLOAT

UNSIGNED_INT
Python: cv.Param_UNSIGNED_INT

UINT64
Python: cv.Param_UINT64

UCHAR
Python: cv.Param_UCHAR

SCALAR
Python: cv.Param_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 inline double cv::determinant(const Matx< _Tp, m, m > & a)

#include <opencv2/core/matx.hpp>

layoutToString()#

std::string cv::layoutToString(DataLayout layout)

#include <opencv2/core/mat.hpp>

makePtr()#

template<typename _Tp, typename ... A1>
static inline Ptr< _Tp > cv::makePtr(const A1 &… a1)

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

Note

This is often used when a function has optional arrays, and you do not want to provide a specific input or output array.

See also

cv::InputArray, cv::OutputArray

Returns — An empty cv::InputArray or cv::OutputArray that can be used as a placeholder.

norm() [1/2]#

template<typename _Tp, int m, int n>
static inline double cv::norm(const Matx< _Tp, m, n > & M)

#include <opencv2/core/matx.hpp>

norm() [2/2]#

template<typename _Tp, int m, int n>
static inline double cv::norm(
const Matx< _Tp, m, n > & M,
int normType )

#include <opencv2/core/matx.hpp>

normalize()#

template<typename _Tp, int cn>
inline Vec< _Tp, cn > cv::normalize(const Vec< _Tp, cn > & v)

#include <opencv2/core/matx.hpp>

operator!=() [1/2]#

bool cv::operator!=(
const MatShape & shape1,
const MatShape & shape2 )

#include <opencv2/core/mat.hpp>

operator!=() [2/2]#

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

#include <opencv2/core/matx.hpp>

operator*() [1/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [2/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [3/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [4/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [5/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [6/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [7/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [8/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [9/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [10/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [11/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [12/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [13/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [14/15]#

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

#include <opencv2/core/matx.hpp>

operator*() [15/15]#

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

#include <opencv2/core/matx.hpp>

operator*=() [1/7]#

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

#include <opencv2/core/matx.hpp>

operator*=() [2/7]#

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

#include <opencv2/core/matx.hpp>

operator*=() [3/7]#

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

#include <opencv2/core/matx.hpp>

operator*=() [4/7]#

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

#include <opencv2/core/matx.hpp>

operator*=() [5/7]#

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

#include <opencv2/core/matx.hpp>

operator*=() [6/7]#

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

#include <opencv2/core/matx.hpp>

operator*=() [7/7]#

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

#include <opencv2/core/matx.hpp>

operator+() [1/2]#

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

#include <opencv2/core/matx.hpp>

operator+() [2/2]#

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

#include <opencv2/core/matx.hpp>

operator+=() [1/2]#

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

#include <opencv2/core/matx.hpp>

operator+=() [2/2]#

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

#include <opencv2/core/matx.hpp>

operator-() [1/4]#

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

#include <opencv2/core/matx.hpp>

operator-() [2/4]#

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

#include <opencv2/core/matx.hpp>

operator-() [3/4]#

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

#include <opencv2/core/matx.hpp>

operator-() [4/4]#

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

#include <opencv2/core/matx.hpp>

operator-=() [1/2]#

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

#include <opencv2/core/matx.hpp>

operator-=() [2/2]#

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

#include <opencv2/core/matx.hpp>

operator/() [1/5]#

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

#include <opencv2/core/matx.hpp>

operator/() [2/5]#

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

#include <opencv2/core/matx.hpp>

operator/() [3/5]#

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

#include <opencv2/core/matx.hpp>

operator/() [4/5]#

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

#include <opencv2/core/matx.hpp>

operator/() [5/5]#

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

#include <opencv2/core/matx.hpp>

operator/=() [1/5]#

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

#include <opencv2/core/matx.hpp>

operator/=() [2/5]#

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

#include <opencv2/core/matx.hpp>

operator/=() [3/5]#

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

#include <opencv2/core/matx.hpp>

operator/=() [4/5]#

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

#include <opencv2/core/matx.hpp>

operator/=() [5/5]#

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

#include <opencv2/core/matx.hpp>

operator<<() [1/2]#

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

#include <opencv2/core.hpp>

Here is the call graph for this function:

operator<<() [2/2]#

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

#include <opencv2/core.hpp>

operator==() [1/2]#

bool cv::operator==(
const MatShape & shape1,
const MatShape & shape2 )

#include <opencv2/core/mat.hpp>

operator==() [2/2]#

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

#include <opencv2/core/matx.hpp>

rawIn()#

template<typename _Tp>
static inline _InputArray cv::rawIn(_Tp & v)

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also

InputArray

rawInOut()#

template<typename _Tp>
static inline _InputOutputArray cv::rawInOut(_Tp & v)

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also

InputArray

rawOut()#

template<typename _Tp>
static inline _OutputArray cv::rawOut(_Tp & v)

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also

InputArray

toLowerCase()#

static inline std::string cv::toLowerCase(const std::string & str)

#include <opencv2/core/cvstd.hpp>

toUpperCase()#

static inline std::string cv::toUpperCase(const std::string & str)

#include <opencv2/core/cvstd.hpp>

trace()#

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

#include <opencv2/core/matx.hpp>

Basic structures#

Detailed Description#

Namespaces#

Classes#

Enumerations#

Shorter aliases for the most popular specializations of Vec<T,n>#

Typedef Documentation#

Vec2b#

Vec3b#

Vec4b#

Vec2s#

Vec3s#

Vec4s#

Vec2w#

Vec3w#

Vec4w#

Vec2i#

Vec3i#

Vec4i#

Vec6i#

Vec8i#

Vec2l#

Vec3l#

Vec4l#

Vec6l#

Vec8l#

Vec2f#

Vec3f#

Vec4f#

Vec6f#

Vec2d#

Vec3d#

Vec4d#

Vec6d#

Complexd#

Complexf#

InputArray#

InputArrayOfArrays#

InputOutputArray#

InputOutputArrayOfArrays#

Mat1b#

Mat1d#

Mat1f#

Mat1i#

Mat1s#

Mat1w#

Mat2b#

Mat2d#

Mat2f#

Mat2i#

Mat2s#

Mat2w#

Mat3b#

Mat3d#

Mat3f#

Mat3i#

Mat3s#

Mat3w#

Mat4b#

Mat4d#

Mat4f#

Mat4i#

Mat4s#

Mat4w#

Matx12d#

Matx12f#

Matx13d#

Matx13f#

Matx14d#

Matx14f#

Matx16d#

Matx16f#

Matx21d#

Matx21f#

Matx22d#

Matx22f#

Matx23d#

Matx23f#

Matx31d#

Matx31f#