OpenCV  4.10.0
Open Source Computer Vision
Loading...
Searching...
No Matches
Basic structures

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 _InputArraycv::InputArray
typedef InputArray cv::InputArrayOfArrays
typedef const _InputOutputArraycv::InputOutputArray
typedef InputOutputArray cv::InputOutputArrayOfArrays
typedef Mat_< ucharcv::Mat1b
typedef Mat_< double > cv::Mat1d
typedef Mat_< float > cv::Mat1f
typedef Mat_< int > cv::Mat1i
typedef Mat_< short > cv::Mat1s
typedef Mat_< ushortcv::Mat1w
typedef Mat_< Vec2bcv::Mat2b
typedef Mat_< Vec2dcv::Mat2d
typedef Mat_< Vec2fcv::Mat2f
typedef Mat_< Vec2icv::Mat2i
typedef Mat_< Vec2scv::Mat2s
typedef Mat_< Vec2wcv::Mat2w
typedef Mat_< Vec3bcv::Mat3b
typedef Mat_< Vec3dcv::Mat3d
typedef Mat_< Vec3fcv::Mat3f
typedef Mat_< Vec3icv::Mat3i
typedef Mat_< Vec3scv::Mat3s
typedef Mat_< Vec3wcv::Mat3w
typedef Mat_< Vec4bcv::Mat4b
typedef Mat_< Vec4dcv::Mat4d
typedef Mat_< Vec4fcv::Mat4f
typedef Mat_< Vec4icv::Mat4i
typedef Mat_< Vec4scv::Mat4s
typedef Mat_< Vec4wcv::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 _OutputArraycv::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_< int64cv::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_< int64cv::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< _Tpcv::makePtr (const A1 &... a1)
InputOutputArray cv::noArray ()
template<typename _Tp, int m, int n>
static double cv::norm (const Matx< _Tp, m, n > &M)
template<typename _Tp, int m, int n>
static double cv::norm (const Matx< _Tp, m, n > &M, int normType)
template<typename _Tp, int cn>
Vec< _Tp, cn > cv::normalize (const Vec< _Tp, cn > &v)
template<typename _Tp, int m, int n>
static bool cv::operator!= (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
template<typename _Tp, int m, int n, int l>
static Matx< _Tp, m, n > cv::operator* (const Matx< _Tp, m, l > &a, const Matx< _Tp, l, n > &b)
template<typename _Tp, int m, int n>
static Vec< _Tp, m > cv::operator* (const Matx< _Tp, m, n > &a, const Vec< _Tp, n > &b)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator* (const Matx< _Tp, m, n > &a, double alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator* (const Matx< _Tp, m, n > &a, float alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator* (const Matx< _Tp, m, n > &a, int alpha)
template<typename _Tp>
Vec< _Tp, 4 > cv::operator* (const Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator* (const Vec< _Tp, cn > &a, double alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator* (const Vec< _Tp, cn > &a, float alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator* (const Vec< _Tp, cn > &a, int alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator* (double alpha, const Matx< _Tp, m, n > &a)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator* (double alpha, const Vec< _Tp, cn > &a)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator* (float alpha, const Matx< _Tp, m, n > &a)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator* (float alpha, const Vec< _Tp, cn > &a)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator* (int alpha, const Matx< _Tp, m, n > &a)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator* (int alpha, const Vec< _Tp, cn > &a)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > & cv::operator*= (Matx< _Tp, m, n > &a, double alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > & cv::operator*= (Matx< _Tp, m, n > &a, float alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > & cv::operator*= (Matx< _Tp, m, n > &a, int alpha)
template<typename _Tp>
Vec< _Tp, 4 > & cv::operator*= (Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2)
template<typename _Tp, int cn>
static Vec< _Tp, cn > & cv::operator*= (Vec< _Tp, cn > &a, double alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > & cv::operator*= (Vec< _Tp, cn > &a, float alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > & cv::operator*= (Vec< _Tp, cn > &a, int alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator+ (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator+ (const Vec< _Tp, cn > &a, const Vec< _Tp, cn > &b)
template<typename _Tp1, typename _Tp2, int m, int n>
static Matx< _Tp1, m, n > & cv::operator+= (Matx< _Tp1, m, n > &a, const Matx< _Tp2, m, n > &b)
template<typename _Tp1, typename _Tp2, int cn>
static Vec< _Tp1, cn > & cv::operator+= (Vec< _Tp1, cn > &a, const Vec< _Tp2, cn > &b)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator- (const Matx< _Tp, m, n > &a)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator- (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator- (const Vec< _Tp, cn > &a)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator- (const Vec< _Tp, cn > &a, const Vec< _Tp, cn > &b)
template<typename _Tp1, typename _Tp2, int m, int n>
static Matx< _Tp1, m, n > & cv::operator-= (Matx< _Tp1, m, n > &a, const Matx< _Tp2, m, n > &b)
template<typename _Tp1, typename _Tp2, int cn>
static Vec< _Tp1, cn > & cv::operator-= (Vec< _Tp1, cn > &a, const Vec< _Tp2, cn > &b)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator/ (const Matx< _Tp, m, n > &a, double alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > cv::operator/ (const Matx< _Tp, m, n > &a, float alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator/ (const Vec< _Tp, cn > &a, double alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator/ (const Vec< _Tp, cn > &a, float alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > cv::operator/ (const Vec< _Tp, cn > &a, int alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > & cv::operator/= (Matx< _Tp, m, n > &a, double alpha)
template<typename _Tp, int m, int n>
static Matx< _Tp, m, n > & cv::operator/= (Matx< _Tp, m, n > &a, float alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > & cv::operator/= (Vec< _Tp, cn > &a, double alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > & cv::operator/= (Vec< _Tp, cn > &a, float alpha)
template<typename _Tp, int cn>
static Vec< _Tp, cn > & cv::operator/= (Vec< _Tp, cn > &a, int alpha)
static Stringcv::operator<< (String &out, const Mat &mtx)
static Stringcv::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

◆ Complexf

typedef Complex<float> cv::Complexf

◆ InputArray

◆ InputArrayOfArrays

◆ InputOutputArray

◆ InputOutputArrayOfArrays

◆ Mat1b

◆ Mat1d

typedef Mat_<double> cv::Mat1d

◆ Mat1f

typedef Mat_<float> cv::Mat1f

◆ Mat1i

typedef Mat_<int> cv::Mat1i

◆ Mat1s

typedef Mat_<short> cv::Mat1s

◆ Mat1w

◆ Mat2b

◆ Mat2d

◆ Mat2f

◆ Mat2i

◆ Mat2s

◆ Mat2w

◆ Mat3b

◆ Mat3d

◆ Mat3f

◆ Mat3i

◆ Mat3s

◆ Mat3w

◆ Mat4b

◆ Mat4d

◆ Mat4f

◆ Mat4i

◆ Mat4s

◆ Mat4w

◆ Matx12d

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

◆ Matx12f

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

◆ Matx13d

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

◆ Matx13f

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

◆ Matx14d

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

◆ Matx14f

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

◆ Matx16d

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

◆ Matx16f

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

◆ Matx21d

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

◆ Matx21f

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

◆ Matx22d

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

◆ Matx22f

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

◆ Matx23d

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

◆ Matx23f

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

◆ Matx31d

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

◆ Matx31f

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

◆ Matx32d

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

◆ Matx32f

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

◆ Matx33d

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

◆ Matx33f

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

◆ Matx34d

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

◆ Matx34f

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

◆ Matx41d

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

◆ Matx41f

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

◆ Matx43d

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

◆ Matx43f

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

◆ Matx44d

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

◆ Matx44f

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

◆ Matx61d

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

◆ Matx61f

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

◆ Matx66d

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

◆ Matx66f

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

◆ OutputArray

◆ OutputArrayOfArrays

◆ Point

◆ Point2d

◆ Point2f

◆ Point2i

typedef Point_<int> cv::Point2i

◆ Point2l

◆ Point3d

typedef Point3_<double> cv::Point3d

◆ Point3f

◆ Point3i

typedef Point3_<int> cv::Point3i

◆ Ptr

◆ Rect

◆ Rect2d

typedef Rect_<double> cv::Rect2d

◆ Rect2f

typedef Rect_<float> cv::Rect2f

◆ Rect2i

typedef Rect_<int> cv::Rect2i

◆ Scalar

typedef Scalar_<double> cv::Scalar

◆ Size

◆ Size2d

typedef Size_<double> cv::Size2d

◆ Size2f

typedef Size_<float> cv::Size2f

◆ Size2i

typedef Size_<int> cv::Size2i

◆ Size2l

◆ String

◆ Vec2b

typedef Vec<uchar, 2> cv::Vec2b

◆ Vec2d

typedef Vec<double, 2> cv::Vec2d

◆ Vec2f

typedef Vec<float, 2> cv::Vec2f

◆ Vec2i

typedef Vec<int, 2> cv::Vec2i

◆ Vec2s

typedef Vec<short, 2> cv::Vec2s

◆ Vec2w

typedef Vec<ushort, 2> cv::Vec2w

◆ Vec3b

◆ Vec3d

typedef Vec<double, 3> cv::Vec3d

◆ Vec3f

typedef Vec<float, 3> cv::Vec3f

◆ Vec3i

◆ Vec3s

typedef Vec<short, 3> cv::Vec3s

◆ Vec3w

typedef Vec<ushort, 3> cv::Vec3w

◆ Vec4b

typedef Vec<uchar, 4> cv::Vec4b

◆ Vec4d

typedef Vec<double, 4> cv::Vec4d

◆ Vec4f

typedef Vec<float, 4> cv::Vec4f

◆ Vec4i

◆ Vec4s

typedef Vec<short, 4> cv::Vec4s

◆ Vec4w

typedef Vec<ushort, 4> cv::Vec4w

◆ Vec6d

typedef Vec<double, 6> cv::Vec6d

◆ Vec6f

typedef Vec<float, 6> cv::Vec6f

◆ Vec6i

typedef Vec<int, 6> cv::Vec6i

◆ Vec8i

typedef Vec<int, 8> cv::Vec8i

Enumeration Type Documentation

◆ 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

#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>
double cv::determinant ( const Matx< _Tp, m, m > & a)
inlinestatic
Python:
cv.determinant(mtx) -> retval

◆ makePtr()

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

◆ noArray()

InputOutputArray cv::noArray ( )

◆ norm() [1/2]

template<typename _Tp, int m, int n>
double cv::norm ( const Matx< _Tp, m, n > & M)
inlinestatic
Python:
cv.norm(src1[, normType[, mask]]) -> retval
cv.norm(src1, src2[, normType[, mask]]) -> retval

◆ norm() [2/2]

template<typename _Tp, int m, int n>
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

◆ 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

◆ operator!=()

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

◆ operator*() [1/15]

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

◆ operator*() [2/15]

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

◆ operator*() [3/15]

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

◆ operator*() [4/15]

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

◆ operator*() [5/15]

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

◆ operator*() [6/15]

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

◆ operator*() [7/15]

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

◆ operator*() [8/15]

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

◆ operator*() [9/15]

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

◆ operator*() [10/15]

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

◆ operator*() [11/15]

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

◆ operator*() [12/15]

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

◆ operator*() [13/15]

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

◆ operator*() [14/15]

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

◆ operator*() [15/15]

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

◆ operator*=() [1/7]

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

◆ operator*=() [2/7]

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

◆ operator*=() [3/7]

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

◆ operator*=() [4/7]

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

◆ operator*=() [5/7]

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

◆ operator*=() [6/7]

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

◆ operator*=() [7/7]

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

◆ operator+() [1/2]

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

◆ operator+() [2/2]

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

◆ operator+=() [1/2]

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

◆ operator+=() [2/2]

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

◆ operator-() [1/4]

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

◆ operator-() [2/4]

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

◆ operator-() [3/4]

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

◆ operator-() [4/4]

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

◆ operator-=() [1/2]

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

◆ operator-=() [2/2]

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

◆ operator/() [1/5]

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

◆ operator/() [2/5]

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

◆ operator/() [3/5]

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

◆ operator/() [4/5]

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

◆ operator/() [5/5]

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

◆ operator/=() [1/5]

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

◆ operator/=() [2/5]

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

◆ operator/=() [3/5]

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

◆ operator/=() [4/5]

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

◆ operator/=() [5/5]

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

◆ operator<<() [1/2]

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

#include <opencv2/core.hpp>

◆ operator<<() [2/2]

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

◆ operator==()

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

◆ rawIn()

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

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also
InputArray

◆ rawInOut()

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

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also
InputArray

◆ rawOut()

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

#include <opencv2/core/mat.hpp>

Helper to wrap custom types.

See also
InputArray

◆ toLowerCase()

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

◆ toUpperCase()

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

◆ trace()

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