| OpenCV 5.0.0alpha Open Source Computer Vision

Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions
Basic structures
Core functionality

## 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::MatShape
| Represents shape of a matrix/tensor. Previously, MatShape was defined as an alias of std::vector<int>, but now we use a special structure that provides a few extra benefits: More...
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 | 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. More...
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)
std::string | cv::layoutToString (DataLayout layout)
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)
bool | cv::operator!= (const MatShape &shape1, const MatShape &shape2)
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)
bool | cv::operator== (const MatShape &shape1, const MatShape &shape2)
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< int64_t, 2 > | cv::Vec2l
typedef Vec< int64_t, 3 > | cv::Vec3l
typedef Vec< int64_t, 4 > | cv::Vec4l
typedef Vec< int64_t, 6 > | cv::Vec6l
typedef Vec< int64_t, 8 > | cv::Vec8l
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>`

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

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

## ◆ Vec2l

typedef Vec<int64_t, 2> cv::Vec2l

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

## ◆ Vec3l

typedef Vec<int64_t, 3> cv::Vec3l

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

## ◆ Vec4l

typedef Vec<int64_t, 4> cv::Vec4l

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

## ◆ Vec6l

typedef Vec<int64_t, 6> cv::Vec6l

`#include <opencv2/core/matx.hpp>`

## ◆ Vec8i

typedef Vec<int, 8> cv::Vec8i

`#include <opencv2/core/matx.hpp>`

## ◆ Vec8l

typedef Vec<int64_t, 8> cv::Vec8l

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

## ◆ 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 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 | ) |
| inline static

Python:
| cv.determinant( | mtx | ) -> | retval

`#include <opencv2/core/matx.hpp>`

## ◆ layoutToString()

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

`#include <opencv2/core/mat.hpp>`

## ◆ makePtr()

template<typename _Tp , typename ... A1>

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

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

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

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

## ◆ norm() [1/2]

template<typename _Tp , int m, int n>

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

Python:
| cv.norm( | src1[, normType[, mask]] | ) -> | retval
| cv.norm( | src1, src2[, normType[, mask]] | ) -> | retval

`#include <opencv2/core/matx.hpp>`

## ◆ norm() [2/2]

template<typename _Tp , int m, int n>

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

Python:
| cv.norm( | src1[, normType[, mask]] | ) -> | retval
| cv.norm( | src1, src2[, normType[, mask]] | ) -> | retval

`#include <opencv2/core/matx.hpp>`

## ◆ normalize()

template<typename _Tp , int cn>

Vec< _Tp, cn > cv::normalize | ( | const Vec< _Tp, cn > & | v | ) |
| inline

Python:
| cv.normalize( | src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]] | ) -> | dst

`#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 bool cv::operator!= | ( | const Matx< _Tp, m, n > & | a,
|  | const Matx< _Tp, m, n > & | b )
| inline static

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [1/15]

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 )
| inline static

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [2/15]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [3/15]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [4/15]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [5/15]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [6/15]

template<typename _Tp >

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [7/15]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [8/15]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [9/15]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [10/15]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [11/15]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [12/15]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [13/15]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [14/15]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*() [15/15]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*=() [1/7]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*=() [2/7]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*=() [3/7]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*=() [4/7]

template<typename _Tp >

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*=() [5/7]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*=() [6/7]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator*=() [7/7]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator+() [1/2]

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 )
| inline static

`#include <opencv2/core/matx.hpp>`

## ◆ operator+() [2/2]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator+=() [1/2]

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 )
| inline static

`#include <opencv2/core/matx.hpp>`

## ◆ operator+=() [2/2]

template<typename _Tp1 , typename _Tp2 , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator-() [1/4]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator-() [2/4]

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 )
| inline static

`#include <opencv2/core/matx.hpp>`

## ◆ operator-() [3/4]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator-() [4/4]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator-=() [1/2]

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 )
| inline static

`#include <opencv2/core/matx.hpp>`

## ◆ operator-=() [2/2]

template<typename _Tp1 , typename _Tp2 , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/() [1/5]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/() [2/5]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/() [3/5]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/() [4/5]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/() [5/5]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/=() [1/5]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/=() [2/5]

template<typename _Tp , int m, int n>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/=() [3/5]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/=() [4/5]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator/=() [5/5]

template<typename _Tp , int cn>

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

`#include <opencv2/core/matx.hpp>`

## ◆ operator<<() [1/2]

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

`#include <opencv2/core.hpp>`

Here is the call graph for this function:

## ◆ operator<<() [2/2]

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

`#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 bool cv::operator== | ( | const Matx< _Tp, m, n > & | a,
|  | const Matx< _Tp, m, n > & | b )
| inline static

`#include <opencv2/core/matx.hpp>`

## ◆ rawIn()

template<typename _Tp >

static _InputArray cv::rawIn | ( | _Tp & | v | ) |
| inline static

`#include <opencv2/core/mat.hpp>`

Helper to wrap custom types.

See also
  InputArray

## ◆ rawInOut()

template<typename _Tp >

static _InputOutputArray cv::rawInOut | ( | _Tp & | v | ) |
| inline static

`#include <opencv2/core/mat.hpp>`

Helper to wrap custom types.

See also
  InputArray

## ◆ rawOut()

template<typename _Tp >

static _OutputArray cv::rawOut | ( | _Tp & | v | ) |
| inline static

`#include <opencv2/core/mat.hpp>`

Helper to wrap custom types.

See also
  InputArray

## ◆ toLowerCase()

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

`#include <opencv2/core/cvstd.hpp>`

## ◆ toUpperCase()

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

`#include <opencv2/core/cvstd.hpp>`

## ◆ trace()

template<typename _Tp , int m, int n>

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

Python:
| cv.trace( | mtx | ) -> | retval

`#include <opencv2/core/matx.hpp>`