OpenCV  4.10.0-dev
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::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 = typedef std::shared_ptr<_Tp>

#include <opencv2/core/cvstd_wrapper.hpp>

◆ Rect

typedef Rect2i cv::Rect

#include <opencv2/core/types.hpp>

◆ Rect2d

typedef Rect_<double> cv::Rect2d

#include <opencv2/core/types.hpp>

◆ Rect2f

typedef Rect_<float> cv::Rect2f

#include <opencv2/core/types.hpp>

◆ Rect2i

typedef Rect_<int> cv::Rect2i

#include <opencv2/core/types.hpp>

◆ Scalar

typedef Scalar_<double> cv::Scalar

#include <opencv2/core/types.hpp>

◆ Size

typedef Size2i cv::Size

#include <opencv2/core/types.hpp>

◆ Size2d

typedef Size_<double> cv::Size2d

#include <opencv2/core/types.hpp>

◆ Size2f

typedef Size_<float> cv::Size2f

#include <opencv2/core/types.hpp>

◆ Size2i

typedef Size_<int> cv::Size2i

#include <opencv2/core/types.hpp>

◆ Size2l

typedef Size_<int64> cv::Size2l

#include <opencv2/core/types.hpp>

◆ String

typedef std::string cv::String

#include <opencv2/core/cvstd.hpp>

◆ Vec2b

typedef Vec<uchar, 2> cv::Vec2b

#include <opencv2/core/matx.hpp>

◆ Vec2d

typedef Vec<double, 2> cv::Vec2d

#include <opencv2/core/matx.hpp>

◆ Vec2f

typedef Vec<float, 2> cv::Vec2f

#include <opencv2/core/matx.hpp>

◆ Vec2i

typedef Vec<int, 2> cv::Vec2i

#include <opencv2/core/matx.hpp>

◆ Vec2s

typedef Vec<short, 2> cv::Vec2s

#include <opencv2/core/matx.hpp>

◆ Vec2w

typedef Vec<ushort, 2> cv::Vec2w

#include <opencv2/core/matx.hpp>

◆ Vec3b

typedef Vec<uchar, 3> cv::Vec3b

#include <opencv2/core/matx.hpp>

◆ Vec3d

typedef Vec<double, 3> cv::Vec3d

#include <opencv2/core/matx.hpp>

◆ Vec3f

typedef Vec<float, 3> cv::Vec3f

#include <opencv2/core/matx.hpp>

◆ Vec3i

typedef Vec<int, 3> cv::Vec3i

#include <opencv2/core/matx.hpp>

◆ Vec3s

typedef Vec<short, 3> cv::Vec3s

#include <opencv2/core/matx.hpp>

◆ Vec3w

typedef Vec<ushort, 3> cv::Vec3w

#include <opencv2/core/matx.hpp>

◆ Vec4b

typedef Vec<uchar, 4> cv::Vec4b

#include <opencv2/core/matx.hpp>

◆ Vec4d

typedef Vec<double, 4> cv::Vec4d

#include <opencv2/core/matx.hpp>

◆ Vec4f

typedef Vec<float, 4> cv::Vec4f

#include <opencv2/core/matx.hpp>

◆ Vec4i

typedef Vec<int, 4> cv::Vec4i

#include <opencv2/core/matx.hpp>

◆ Vec4s

typedef Vec<short, 4> cv::Vec4s

#include <opencv2/core/matx.hpp>

◆ Vec4w

typedef Vec<ushort, 4> cv::Vec4w

#include <opencv2/core/matx.hpp>

◆ Vec6d

typedef Vec<double, 6> cv::Vec6d

#include <opencv2/core/matx.hpp>

◆ Vec6f

typedef Vec<float, 6> cv::Vec6f

#include <opencv2/core/matx.hpp>

◆ Vec6i

typedef Vec<int, 6> cv::Vec6i

#include <opencv2/core/matx.hpp>

◆ Vec8i

typedef Vec<int, 8> cv::Vec8i

#include <opencv2/core/matx.hpp>

Enumeration Type Documentation

◆ AccessFlag

enum cv::AccessFlag

#include <opencv2/core/mat.hpp>

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

◆ Param

enum struct cv::Param
strong

#include <opencv2/core.hpp>

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

◆ UMatUsageFlags

enum cv::UMatUsageFlags

#include <opencv2/core/mat.hpp>

Usage flags for allocator.

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

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.

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)
inlinestatic
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 
)
inlinestatic
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!=()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <opencv2/core/matx.hpp>

◆ operator-() [3/4]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <opencv2/core/matx.hpp>

◆ operator<<() [1/2]

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

#include <opencv2/core.hpp>

◆ operator<<() [2/2]

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

#include <opencv2/core.hpp>

◆ operator==()

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

#include <opencv2/core/matx.hpp>

◆ rawIn()

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

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also
InputArray

◆ rawInOut()

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

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also
InputArray

◆ rawOut()

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

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also
InputArray

◆ toLowerCase()

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

#include <opencv2/core/cvstd.hpp>

◆ toUpperCase()

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

#include <opencv2/core/cvstd.hpp>

◆ trace()

template<typename _Tp , int m, int n>
static double cv::trace ( const Matx< _Tp, m, n > &  a)
inlinestatic
Python:
cv.trace(mtx) -> retval

#include <opencv2/core/matx.hpp>

Generated on Wed Nov 20 2024 23:10:27 for OpenCV by   doxygen 1.9.8