Module core

Expand description

§Core functionality

The Core module is the backbone of OpenCV, offering fundamental data structures, matrix operations, and utility functions that other modules depend on. It’s essential for handling image data, performing mathematical computations, and managing memory efficiently within the OpenCV ecosystem.

§Basic structures

§Operations on arrays

§Asynchronous API

§XML/YAML/JSON Persistence

§Clustering

§Utility and system functions and macros

§OpenGL interoperability

§Optimization Algorithms

§DirectX interoperability

§Eigen support

§OpenCL support

§Intel VA-API/OpenCL (CL-VA) interoperability

§Hardware Acceleration Layer

§Parallel Processing

§Quaternion

Modules§

prelude

Structs§

Affine3: docs.opencv.org
Algorithm: This is a base class for all more or less complex algorithms in OpenCV
Arrays: Wrapper for OpenGL Client-Side Vertex arrays.
AsyncArray: Returns result of asynchronous operations
AsyncPromise: Provides result of asynchronous operations
Buffer: Smart pointer for OpenGL buffer object with reference counting.
BufferPool: BufferPool for use with CUDA streams
ClassWithKeywordProperties
CommandLineParser: Designed for command line parsing
ConjGradSolver: This class is used to perform the non-linear non-constrained minimization of a function with known gradient,
Context
Context_UserContext
DMatch: Class for matching keypoint descriptors
Detail_CheckContext
Device
DeviceInfo: Class providing functionality for querying the specified GPU properties.
DownhillSolver: This class is used to perform the non-linear non-constrained minimization of a function,
Event
Exception: ! Class passed to an error.
FileNode: File Storage Node class.
FileNodeIterator: used to iterate through sequences and mappings.
FileStorage: XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or reading data to/from a file.
Formatted: @todo document
Formatter: @todo document
FunctionParams
GpuData
GpuMat: Base storage class for GPU memory with reference counting.
GpuMatND
GpuMat_Allocator
Hamming
HostMem: Class with reference counting wrapping special memory type allocation functions from CUDA.
Image2D
Kernel
KernelArg
KeyPoint: Data structure for salient point detectors.
LDA: Linear Discriminant Analysis @todo document this class
LogTag
Mat: n-dimensional dense array class \anchor CVMat_Details
MatConstIterator: /////////////////////////////// MatConstIterator //////////////////////////////////
MatExpr: Matrix expression representation @anchor MatrixExpressions 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 )):
MatIter
MatIterMut
MatOp: ////////////////////////////// Matrix Expressions /////////////////////////////////
MatSize
MatStep
Mat_: docs.opencv.org
Matx: docs.opencv.org
Matx_AddOp: @cond IGNORED
Matx_DivOp
Matx_MatMulOp
Matx_MulOp
Matx_ScaleOp
Matx_SubOp
Matx_TOp
MinProblemSolver: Basic interface for all solvers
MinProblemSolver_Function: Represents function being optimized
Moments: struct returned by cv::moments
NodeData
OpenCLExecutionContext
OriginalClassName
OriginalClassName_Params
PCA: Principal Component Analysis
ParallelLoopBody: Base class for parallel data processors
Platform: @deprecated
PlatformInfo
Point3_: docs.opencv.org
Point_: docs.opencv.org
Program
ProgramSource
Ptr: This is similar to Rust Arc, but handled by the C++. Some OpenCV functions insist on accepting Ptr instead of a heap allocated object, so we need to satisfy those.
Queue
RNG: Random Number Generator
RNG_MT19937: Mersenne Twister random number generator
Range: Template class specifying a continuous subsequence (slice) of a sequence.
Rect_: docs.opencv.org
RotatedRect: The class represents rotated (i.e. not up-right) rectangles on a plane.
SVD: Singular Value Decomposition
Size_: docs.opencv.org
SizedArray12
SizedArray13
SizedArray14
SizedArray16
SizedArray21
SizedArray22
SizedArray23
SizedArray31
SizedArray32
SizedArray33
SizedArray34
SizedArray41
SizedArray43
SizedArray44
SizedArray61
SizedArray66
SparseMat: The class SparseMat represents multi-dimensional sparse numerical arrays.
SparseMatConstIterator: Read-Only Sparse Matrix Iterator.
SparseMatIterator: Read-write Sparse Matrix Iterator
SparseMat_Hdr: the sparse matrix header
SparseMat_Node: sparse matrix node - element of a hash table
Stream: This class encapsulates a queue of asynchronous calls.
TargetArchs: Class providing a set of static methods to check what NVIDIA* card architecture the CUDA module was built for.
TermCriteria: The class defining termination criteria for iterative algorithms.
Texture2D: Smart pointer for OpenGL 2D texture memory with reference counting.
TickMeter: a Class to measure passing time.
Timer
Tuple: Wrapper for C++ std::tupe and std::pair
UMat: @todo document
UMatData
VecN: docs.opencv.org Named VecN to avoid name clash with std’s Vec.
Vector: Wrapper for C++ std::vector
VectorIterator
VectorRefIterator
WriteStructContext
_InputArray: This is the proxy class for passing read-only input arrays into OpenCV functions.
_InputOutputArray
_OutputArray: This type is very similar to InputArray except that it is used for input/output and output function parameters.
hfloat

Enums§

AccessFlag
AlgorithmHint: ! Flags that allow to midify some functions behavior. Used as set of flags.
BorderTypes: Various border types, image boundaries are denoted with |
Buffer_Access
Buffer_Target: The target defines how you intend to use the buffer object.
CmpTypes: comparison types
Code: error codes
CovarFlags: Covariation flags
CpuFeatures: Available CPU features.
DecompTypes: matrix decomposition types
Detail_TestOp
DeviceInfo_ComputeMode
DftFlags
Event_CreateFlags
FLAGS
FeatureSet: Enumeration providing CUDA computing features.
FileStorage_Mode: file storage mode
FileStorage_State
Formatter_FormatType
GemmFlags: generalized matrix multiplication flags
HostMem_AllocType
IMPL
KmeansFlags: k-means flags
LogLevel: Supported logging levels and their semantic
MatExprResult: Intermediate result type that’s produced by the Mat operations. Call MatExprResult::into_result to get the regular Result.
NormTypes: norm types
OclVectorStrategy
PCA_Flags
Param
ReduceTypes
RenderModes: render mode
RotateFlags
SVD_Flags
SolveLPResult: return codes for cv::solveLP() function
SortFlags
TYPE
TermCriteria_Type: Criteria type, can be one of: COUNT, EPS or COUNT + EPS
Texture2D_Format: An Image Format describes the way that the images in Textures store their data.
UMatData_MemoryFlag
UMatUsageFlags: Usage flags for allocator
_InputArray_KindFlag
_OutputArray_DepthMask

Constants§

ACCESS_FAST
ACCESS_MASK
ACCESS_READ
ACCESS_RW
ACCESS_WRITE
ALGO_HINT_ACCURATE: Use generic portable implementation
ALGO_HINT_APPROX: Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform
ALGO_HINT_DEFAULT: Default algorithm behaviour defined during OpenCV build
BORDER_CONSTANT: iiiiii|abcdefgh|iiiiiii with some specified i
BORDER_DEFAULT: same as BORDER_REFLECT_101
BORDER_ISOLATED: Interpolation restricted within the ROI boundaries.
BORDER_REFLECT: fedcba|abcdefgh|hgfedcb
BORDER_REFLECT101: same as BORDER_REFLECT_101
BORDER_REFLECT_101: gfedcb|abcdefgh|gfedcba
BORDER_REPLICATE: aaaaaa|abcdefgh|hhhhhhh
BORDER_TRANSPARENT: uvwxyz|abcdefgh|ijklmno - Treats outliers as transparent.
BORDER_WRAP: cdefgh|abcdefgh|abcdefg
BadAlign: incorrect input align
BadAlphaChannel
BadCOI: input COI is not supported
BadCallBack
BadDataPtr
BadDepth: input image depth is not supported by the function
BadImageSize: image size is invalid
BadModelOrChSeq
BadNumChannel1U
BadNumChannels: bad number of channels, for example, some functions accept only single channel matrices.
BadOffset: offset is invalid
BadOrder: number of dimensions is out of range
BadOrigin: incorrect input origin
BadROISize: incorrect input roi
BadStep: image step is wrong, this may happen for a non-continuous matrix.
BadTileSize
Buffer_ARRAY_BUFFER: The buffer will be used as a source for vertex data
Buffer_ELEMENT_ARRAY_BUFFER: The buffer will be used for indices (in glDrawElements, for example)
Buffer_PIXEL_PACK_BUFFER: The buffer will be used for reading from OpenGL textures
Buffer_PIXEL_UNPACK_BUFFER: The buffer will be used for writing to OpenGL textures
Buffer_READ_ONLY
Buffer_READ_WRITE
Buffer_WRITE_ONLY
CMP_EQ: src1 is equal to src2.
CMP_GE: src1 is greater than or equal to src2.
CMP_GT: src1 is greater than src2.
CMP_LE: src1 is less than or equal to src2.
CMP_LT: src1 is less than src2.
CMP_NE: src1 is unequal to src2.
COVAR_COLS: If the flag is specified, all the input vectors are stored as columns of the samples matrix. mean should be a single-column vector in this case.
COVAR_NORMAL: The output covariance matrix is calculated as: block formula covar will be a square matrix of the same size as the total number of elements in each input vector. One and only one of COVAR_SCRAMBLED and COVAR_NORMAL must be specified.
COVAR_ROWS: If the flag is specified, all the input vectors are stored as rows of the samples matrix. mean should be a single-row vector in this case.
COVAR_SCALE: If the flag is specified, the covariance matrix is scaled. In the “normal” mode, scale is 1./nsamples . In the “scrambled” mode, scale is the reciprocal of the total number of elements in each input vector. By default (if the flag is not specified), the covariance matrix is not scaled ( scale=1 ).
COVAR_SCRAMBLED: The output covariance matrix is calculated as: block formula The covariance matrix will be nsamples x nsamples. Such an unusual covariance matrix is used for fast PCA of a set of very large vectors (see, for example, the EigenFaces technique for face recognition). Eigenvalues of this “scrambled” matrix match the eigenvalues of the true covariance matrix. The “true” eigenvectors can be easily calculated from the eigenvectors of the “scrambled” covariance matrix.
COVAR_USE_AVG: If the flag is specified, the function does not calculate mean from the input vectors but, instead, uses the passed mean vector. This is useful if mean has been pre-calculated or known in advance, or if the covariance matrix is calculated by parts. In this case, mean is not a mean vector of the input sub-set of vectors but rather the mean vector of the whole set.
CPU_AVX
CPU_AVX2
CPU_AVX512_CLX: Cascade Lake with AVX-512F/CD/BW/DQ/VL/VNNI
CPU_AVX512_CNL: Cannon Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI
CPU_AVX512_COMMON: Common instructions AVX-512F/CD for all CPUs that support AVX-512
CPU_AVX512_ICL: Ice Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI/VNNI/VBMI2/BITALG/VPOPCNTDQ
CPU_AVX512_KNL: Knights Landing with AVX-512F/CD/ER/PF
CPU_AVX512_KNM: Knights Mill with AVX-512F/CD/ER/PF/4FMAPS/4VNNIW/VPOPCNTDQ
CPU_AVX512_SKX: Skylake-X with AVX-512F/CD/BW/DQ/VL
CPU_AVX_512BITALG
CPU_AVX_512BW
CPU_AVX_512CD
CPU_AVX_512DQ
CPU_AVX_512ER
CPU_AVX_512F
CPU_AVX_512IFMA
CPU_AVX_512IFMA512
CPU_AVX_512PF
CPU_AVX_512VBMI
CPU_AVX_512VBMI2
CPU_AVX_512VL
CPU_AVX_512VNNI
CPU_AVX_512VPOPCNTDQ
CPU_AVX_5124FMAPS
CPU_AVX_5124VNNIW
CPU_FMA3
CPU_FP16
CPU_LASX
CPU_LSX
CPU_MAX_FEATURE
CPU_MMX
CPU_MSA
CPU_NEON
CPU_NEON_BF16
CPU_NEON_DOTPROD
CPU_NEON_FP16
CPU_POPCNT
CPU_RISCVV
CPU_RVV
CPU_SSE
CPU_SSE2
CPU_SSE3
CPU_SSE4_1
CPU_SSE4_2
CPU_SSSE3
CPU_VSX
CPU_VSX3
CV_2PI
CV_8S
CV_8SC1
CV_8SC2
CV_8SC3
CV_8SC4
CV_8U
CV_8UC1
CV_8UC2
CV_8UC3
CV_8UC4
CV_16F
CV_16FC1
CV_16FC2
CV_16FC3
CV_16FC4
CV_16S
CV_16SC1
CV_16SC2
CV_16SC3
CV_16SC4
CV_16U
CV_16UC1
CV_16UC2
CV_16UC3
CV_16UC4
CV_32F
CV_32FC1
CV_32FC2
CV_32FC3
CV_32FC4
CV_32S
CV_32SC1
CV_32SC2
CV_32SC3
CV_32SC4
CV_64F
CV_64FC1
CV_64FC2
CV_64FC3
CV_64FC4
CV_AVX
CV_AVX2
CV_AVX512_CLX
CV_AVX512_CNL
CV_AVX512_COMMON
CV_AVX512_ICL
CV_AVX512_KNL
CV_AVX512_KNM
CV_AVX512_SKX
CV_AVX_512BITALG
CV_AVX_512BW
CV_AVX_512CD
CV_AVX_512DQ
CV_AVX_512ER
CV_AVX_512F
CV_AVX_512IFMA
CV_AVX_512IFMA512
CV_AVX_512PF
CV_AVX_512VBMI
CV_AVX_512VBMI2
CV_AVX_512VL
CV_AVX_512VNNI
CV_AVX_512VPOPCNTDQ
CV_AVX_5124FMAPS
CV_AVX_5124VNNIW
CV_CN_MAX
CV_CN_SHIFT
CV_CPU_AVX
CV_CPU_AVX2
CV_CPU_AVX512_CLX
CV_CPU_AVX512_CNL
CV_CPU_AVX512_COMMON
CV_CPU_AVX512_ICL
CV_CPU_AVX512_KNL
CV_CPU_AVX512_KNM
CV_CPU_AVX512_SKX
CV_CPU_AVX_512BITALG
CV_CPU_AVX_512BW
CV_CPU_AVX_512CD
CV_CPU_AVX_512DQ
CV_CPU_AVX_512ER
CV_CPU_AVX_512F
CV_CPU_AVX_512IFMA
CV_CPU_AVX_512IFMA512
CV_CPU_AVX_512PF
CV_CPU_AVX_512VBMI
CV_CPU_AVX_512VBMI2
CV_CPU_AVX_512VL
CV_CPU_AVX_512VNNI
CV_CPU_AVX_512VPOPCNTDQ
CV_CPU_AVX_5124FMAPS
CV_CPU_AVX_5124VNNIW
CV_CPU_FMA3
CV_CPU_FP16
CV_CPU_LASX
CV_CPU_LSX
CV_CPU_MMX
CV_CPU_MSA
CV_CPU_NEON
CV_CPU_NEON_BF16
CV_CPU_NEON_DOTPROD
CV_CPU_NEON_FP16
CV_CPU_NONE
CV_CPU_POPCNT
CV_CPU_RISCVV
CV_CPU_RVV
CV_CPU_SSE
CV_CPU_SSE2
CV_CPU_SSE3
CV_CPU_SSE4_1
CV_CPU_SSE4_2
CV_CPU_SSSE3
CV_CPU_VSX
CV_CPU_VSX3
CV_CXX11
CV_DEPTH_MAX
CV_ENABLE_UNROLLED
CV_FMA3
CV_FP16
CV_FP16_TYPE
CV_HAL_BORDER_CONSTANT
CV_HAL_BORDER_ISOLATED
CV_HAL_BORDER_REFLECT
CV_HAL_BORDER_REFLECT_101
CV_HAL_BORDER_REPLICATE
CV_HAL_BORDER_TRANSPARENT
CV_HAL_BORDER_WRAP
CV_HAL_CMP_EQ
CV_HAL_CMP_GE
CV_HAL_CMP_GT
CV_HAL_CMP_LE
CV_HAL_CMP_LT
CV_HAL_CMP_NE
CV_HAL_DFT_COMPLEX_OUTPUT
CV_HAL_DFT_INVERSE
CV_HAL_DFT_IS_CONTINUOUS
CV_HAL_DFT_IS_INPLACE
CV_HAL_DFT_REAL_OUTPUT
CV_HAL_DFT_ROWS
CV_HAL_DFT_SCALE
CV_HAL_DFT_STAGE_COLS
CV_HAL_DFT_TWO_STAGE
CV_HAL_ERROR_NOT_IMPLEMENTED
CV_HAL_ERROR_OK
CV_HAL_ERROR_UNKNOWN
CV_HAL_GEMM_1_T
CV_HAL_GEMM_2_T
CV_HAL_GEMM_3_T
CV_HAL_SVD_FULL_UV
CV_HAL_SVD_MODIFY_A
CV_HAL_SVD_NO_UV
CV_HAL_SVD_SHORT_UV
CV_HARDWARE_MAX_FEATURE
CV_IMPL_IPP
CV_IMPL_MT
CV_IMPL_OCL
CV_IMPL_PLAIN
CV_LASX
CV_LOG2
CV_LOG_LEVEL_DEBUG
CV_LOG_LEVEL_ERROR
CV_LOG_LEVEL_FATAL
CV_LOG_LEVEL_INFO
CV_LOG_LEVEL_SILENT
CV_LOG_LEVEL_VERBOSE
CV_LOG_LEVEL_WARN
CV_LOG_STRIP_LEVEL
CV_LSX
CV_MAJOR_VERSION
CV_MAT_CN_MASK
CV_MAT_CONT_FLAG
CV_MAT_CONT_FLAG_SHIFT
CV_MAT_DEPTH_MASK
CV_MAT_TYPE_MASK
CV_MAX_DIM
CV_MINOR_VERSION
CV_MMX
CV_MSA
CV_NEON
CV_PI
CV_POPCNT
CV_RVV
CV_RVV071
CV_SSE
CV_SSE2
CV_SSE3
CV_SSE4_1
CV_SSE4_2
CV_SSSE3
CV_STRONG_ALIGNMENT
CV_SUBMAT_FLAG
CV_SUBMAT_FLAG_SHIFT
CV_SUBMINOR_VERSION
CV_VERSION
CV_VERSION_MAJOR
CV_VERSION_MINOR
CV_VERSION_REVISION
CV_VERSION_STATUS
CV_VSX
CV_VSX3
CV_WASM_SIMD
CV__EXCEPTION_PTR
DCT_INVERSE: performs an inverse 1D or 2D transform instead of the default forward transform.
DCT_ROWS: performs a forward or inverse transform of every individual row of the input matrix. This flag enables you to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself) to perform 3D and higher-dimensional transforms and so forth.
DECOMP_CHOLESKY: Cholesky inline formula factorization; the matrix src1 must be symmetrical and positively defined
DECOMP_EIG: eigenvalue decomposition; the matrix src1 must be symmetrical
DECOMP_LU: Gaussian elimination with the optimal pivot element chosen.
DECOMP_NORMAL: while all the previous flags are mutually exclusive, this flag can be used together with any of the previous; it means that the normal equations inline formula are solved instead of the original system inline formula
DECOMP_QR: QR factorization; the system can be over-defined and/or the matrix src1 can be singular
DECOMP_SVD: singular value decomposition (SVD) method; the system can be over-defined and/or the matrix src1 can be singular
DFT_COMPLEX_INPUT: specifies that input is complex input. If this flag is set, the input must have 2 channels. On the other hand, for backwards compatibility reason, if input has 2 channels, input is already considered complex.
DFT_COMPLEX_OUTPUT: performs a forward transformation of 1D or 2D real array; the result, though being a complex array, has complex-conjugate symmetry (CCS, see the function description below for details), and such an array can be packed into a real array of the same size as input, which is the fastest option and which is what the function does by default; however, you may wish to get a full complex array (for simpler spectrum analysis, and so on) - pass the flag to enable the function to produce a full-size complex output array.
DFT_INVERSE: performs an inverse 1D or 2D transform instead of the default forward transform.
DFT_REAL_OUTPUT: performs an inverse transformation of a 1D or 2D complex array; the result is normally a complex array of the same size, however, if the input array has conjugate-complex symmetry (for example, it is a result of forward transformation with DFT_COMPLEX_OUTPUT flag), the output is a real array; while the function itself does not check whether the input is symmetrical or not, you can pass the flag and then the function will assume the symmetry and produce the real output array (note that when the input is packed into a real array and inverse transformation is executed, the function treats the input as a packed complex-conjugate symmetrical array, and the output will also be a real array).
DFT_ROWS: performs a forward or inverse transform of every individual row of the input matrix; this flag enables you to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself) to perform 3D and higher-dimensional transformations and so forth.
DFT_SCALE: scales the result: divide it by the number of array elements. Normally, it is combined with DFT_INVERSE.
DYNAMIC_PARALLELISM
Detail_CV__LAST_TEST_OP
Detail_TEST_CUSTOM
Detail_TEST_EQ
Detail_TEST_GE
Detail_TEST_GT
Detail_TEST_LE
Detail_TEST_LT
Detail_TEST_NE
DeviceInfo_ComputeModeDefault: < default compute mode (Multiple threads can use cudaSetDevice with this device)
DeviceInfo_ComputeModeExclusive: < compute-exclusive-thread mode (Only one thread in one process will be able to use cudaSetDevice with this device)
DeviceInfo_ComputeModeExclusiveProcess: < compute-exclusive-process mode (Many threads in one process will be able to use cudaSetDevice with this device)
DeviceInfo_ComputeModeProhibited: < compute-prohibited mode (No threads can use cudaSetDevice with this device)
Device_EXEC_KERNEL
Device_EXEC_NATIVE_KERNEL
Device_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT
Device_FP_DENORM
Device_FP_FMA
Device_FP_INF_NAN
Device_FP_ROUND_TO_INF
Device_FP_ROUND_TO_NEAREST
Device_FP_ROUND_TO_ZERO
Device_FP_SOFT_FLOAT
Device_LOCAL_IS_GLOBAL
Device_LOCAL_IS_LOCAL
Device_NO_CACHE
Device_NO_LOCAL_MEM
Device_READ_ONLY_CACHE
Device_READ_WRITE_CACHE
Device_TYPE_ACCELERATOR
Device_TYPE_ALL
Device_TYPE_CPU
Device_TYPE_DEFAULT
Device_TYPE_DGPU
Device_TYPE_GPU
Device_TYPE_IGPU
Device_UNKNOWN_VENDOR
Device_VENDOR_AMD
Device_VENDOR_INTEL
Device_VENDOR_NVIDIA
ENUM_LOG_LEVEL_FORCE_INT
Event_BLOCKING_SYNC: < Event uses blocking synchronization
Event_DEFAULT: < Default event flag
Event_DISABLE_TIMING: < Event will not record timing data
Event_INTERPROCESS: < Event is suitable for interprocess use. DisableTiming must be set
FEATURE_SET_COMPUTE_10
FEATURE_SET_COMPUTE_11
FEATURE_SET_COMPUTE_12
FEATURE_SET_COMPUTE_13
FEATURE_SET_COMPUTE_20
FEATURE_SET_COMPUTE_21
FEATURE_SET_COMPUTE_30
FEATURE_SET_COMPUTE_32
FEATURE_SET_COMPUTE_35
FEATURE_SET_COMPUTE_50
FLAGS_EXPAND_SAME_NAMES
FLAGS_MAPPING
FLAGS_NONE
FileNode_EMPTY: empty structure (sequence or mapping)
FileNode_FLOAT: synonym or REAL
FileNode_FLOW: compact representation of a sequence or mapping. Used only by YAML writer
FileNode_INT: an integer
FileNode_MAP: mapping
FileNode_NAMED: the node has a name (i.e. it is element of a mapping).
FileNode_NONE: empty node
FileNode_REAL: floating-point number
FileNode_SEQ: sequence
FileNode_STR: text string in UTF-8 encoding
FileNode_STRING: synonym for STR
FileNode_TYPE_MASK
FileNode_UNIFORM: if set, means that all the collection elements are numbers of the same type (real’s or int’s). UNIFORM is used only when reading FileStorage; FLOW is used only when writing. So they share the same bit
FileStorage_APPEND: value, open the file for appending
FileStorage_BASE64: flag, write rawdata in Base64 by default. (consider using WRITE_BASE64)
FileStorage_FORMAT_AUTO: flag, auto format
FileStorage_FORMAT_JSON: flag, JSON format
FileStorage_FORMAT_MASK: mask for format flags
FileStorage_FORMAT_XML: flag, XML format
FileStorage_FORMAT_YAML: flag, YAML format
FileStorage_INSIDE_MAP: Indicates being inside a map (a set of key-value pairs).
FileStorage_MEMORY: < flag, read data from source or write data to the internal buffer (which is returned by FileStorage::release)
FileStorage_NAME_EXPECTED: Expecting a key/name in the current position.
FileStorage_READ: value, open the file for reading
FileStorage_UNDEFINED: Initial or uninitialized state.
FileStorage_VALUE_EXPECTED: Expecting a value in the current position.
FileStorage_WRITE: value, open the file for writing
FileStorage_WRITE_BASE64: flag, enable both WRITE and BASE64
Formatter_FMT_C
Formatter_FMT_CSV
Formatter_FMT_DEFAULT
Formatter_FMT_MATLAB
Formatter_FMT_NUMPY
Formatter_FMT_PYTHON
GEMM_1_T: transposes src1
GEMM_2_T: transposes src2
GEMM_3_T: transposes src3
GLOBAL_ATOMICS
GpuApiCallError: GPU API call error
GpuNotSupported: no CUDA support
HeaderIsNull: image header is NULL
HostMem_PAGE_LOCKED
HostMem_SHARED
HostMem_WRITE_COMBINED
IMPL_IPP
IMPL_OPENCL
IMPL_PLAIN
KMEANS_PP_CENTERS: Use kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].
KMEANS_RANDOM_CENTERS: Select random initial centers in each attempt.
KMEANS_USE_INITIAL_LABELS: During the first (and possibly the only) attempt, use the user-supplied labels instead of computing them from the initial centers. For the second and further attempts, use the random or semi-random centers. Use one of KMEANS_*_CENTERS flag to specify the exact method.
KernelArg_CONSTANT
KernelArg_LOCAL
KernelArg_NO_SIZE
KernelArg_PTR_ONLY
KernelArg_READ_ONLY
KernelArg_READ_WRITE
KernelArg_WRITE_ONLY
LINES
LINE_LOOP
LINE_STRIP
LOG_LEVEL_DEBUG: Debug message. Disabled in the “Release” build.
LOG_LEVEL_ERROR: Error message
LOG_LEVEL_FATAL: Fatal (critical) error (unrecoverable internal error)
LOG_LEVEL_INFO: Info message
LOG_LEVEL_SILENT: for using in setLogVevel() call
LOG_LEVEL_VERBOSE: Verbose (trace) messages. Requires verbosity level. Disabled in the “Release” build.
LOG_LEVEL_WARNING: Warning message
MaskIsTiled
Mat_AUTO_STEP
Mat_CONTINUOUS_FLAG
Mat_DEPTH_MASK
Mat_MAGIC_MASK
Mat_MAGIC_VAL
Mat_SUBMATRIX_FLAG
Mat_TYPE_MASK
NATIVE_DOUBLE
NORM_HAMMING: In the case of one input array, calculates the Hamming distance of the array from zero, In the case of two input arrays, calculates the Hamming distance between the arrays.
NORM_HAMMING2: Similar to NORM_HAMMING, but in the calculation, each two bits of the input sequence will be added and treated as a single bit to be used in the same calculation as NORM_HAMMING.
NORM_INF: block formula
NORM_L1: block formula
NORM_L2: block formula
NORM_L2SQR: block formula
NORM_MINMAX: flag
NORM_RELATIVE: flag
NORM_TYPE_MASK: bit-mask which can be used to separate norm type from norm flags
OCL_VECTOR_DEFAULT
OCL_VECTOR_MAX
OCL_VECTOR_OWN
OPENCV_ABI_COMPATIBILITY
OPENCV_USE_FASTMATH_BUILTINS
OpenCLApiCallError: OpenCL API call error
OpenCLDoubleNotSupported
OpenCLInitError: OpenCL initialization error
OpenCLNoAMDBlasFft
OpenGlApiCallError: OpenGL API call error
OpenGlNotSupported: no OpenGL support
PCA_DATA_AS_COL: indicates that the input samples are stored as matrix columns
PCA_DATA_AS_ROW: indicates that the input samples are stored as matrix rows
PCA_USE_AVG
POINTS
POLYGON
Param_ALGORITHM
Param_BOOLEAN
Param_FLOAT
Param_INT
Param_MAT
Param_MAT_VECTOR
Param_REAL
Param_SCALAR
Param_STRING
Param_UCHAR
Param_UINT64
Param_UNSIGNED_INT
QUADS
QUAD_STRIP
REDUCE_AVG: the output is the mean vector of all rows/columns of the matrix.
REDUCE_MAX: the output is the maximum (column/row-wise) of all rows/columns of the matrix.
REDUCE_MIN: the output is the minimum (column/row-wise) of all rows/columns of the matrix.
REDUCE_SUM: the output is the sum of all rows/columns of the matrix.
REDUCE_SUM2: the output is the sum of all squared rows/columns of the matrix.
RNG_NORMAL
RNG_UNIFORM
ROTATE_90_CLOCKWISE: Rotate 90 degrees clockwise
ROTATE_90_COUNTERCLOCKWISE: Rotate 270 degrees clockwise
ROTATE_180: Rotate 180 degrees clockwise
SHARED_ATOMICS
SOLVELP_LOST: problem is feasible, but solver lost solution due to floating-point arithmetic errors
SOLVELP_MULTI: there are multiple maxima for target function - the arbitrary one is returned
SOLVELP_SINGLE: there is only one maximum for target function
SOLVELP_UNBOUNDED: problem is unbounded (target function can achieve arbitrary high values)
SOLVELP_UNFEASIBLE: problem is unfeasible (there are no points that satisfy all the constraints imposed)
SORT_ASCENDING: each matrix row is sorted in the ascending order.
SORT_DESCENDING: each matrix row is sorted in the descending order; this flag and the previous one are also mutually exclusive.
SORT_EVERY_COLUMN: each matrix column is sorted independently; this flag and the previous one are mutually exclusive.
SORT_EVERY_ROW: each matrix row is sorted independently
SVD_FULL_UV: when the matrix is not square, by default the algorithm produces u and vt matrices of sufficiently large size for the further A reconstruction; if, however, FULL_UV flag is specified, u and vt will be full-size square orthogonal matrices.
SVD_MODIFY_A: allow the algorithm to modify the decomposed matrix; it can save space and speed up processing. currently ignored.
SVD_NO_UV: indicates that only a vector of singular values w is to be processed, while u and vt will be set to empty matrices
SparseMat_HASH_BIT
SparseMat_HASH_SCALE
SparseMat_MAGIC_VAL
SparseMat_MAX_DIM
StsAssert: assertion failed
StsAutoTrace: tracing
StsBackTrace: pseudo error for back trace
StsBadArg: function arg/param is bad
StsBadFlag: flag is wrong or not supported
StsBadFunc: unsupported function
StsBadMask: bad format of mask (neither 8uC1 nor 8sC1)
StsBadMemBlock: an allocated block has been corrupted
StsBadPoint: bad CvPoint
StsBadSize: the input/output structure size is incorrect
StsDivByZero: division by zero
StsError: unknown /unspecified error
StsFilterOffsetErr: incorrect filter offset value
StsFilterStructContentErr: incorrect filter structure content
StsInplaceNotSupported: in-place operation is not supported
StsInternal: internal error (bad state)
StsKernelStructContentErr: incorrect transform kernel content
StsNoConv: iteration didn’t converge
StsNoMem: insufficient memory
StsNotImplemented: the requested function/feature is not implemented
StsNullPtr: null pointer
StsObjectNotFound: request can’t be completed
StsOk: everything is ok
StsOutOfRange: some of parameters are out of range
StsParseError: invalid syntax/structure of the parsed file
StsUnmatchedFormats: formats of input/output arrays differ
StsUnmatchedSizes: sizes of input/output structures do not match
StsUnsupportedFormat: the data format/type is not supported by the function
StsVecLengthErr: incorrect vector length
TRIANGLES
TRIANGLE_FAN
TRIANGLE_STRIP
TYPE_FUN
TYPE_GENERAL
TYPE_MARKER
TYPE_WRAPPER
TermCriteria_COUNT: the maximum number of iterations or elements to compute
TermCriteria_EPS: the desired accuracy or change in parameters at which the iterative algorithm stops
TermCriteria_MAX_ITER: ditto
Texture2D_DEPTH_COMPONENT: Depth
Texture2D_NONE
Texture2D_RGB: Red, Green, Blue
Texture2D_RGBA: Red, Green, Blue, Alpha
UMatData_ASYNC_CLEANUP
UMatData_COPY_ON_MAP
UMatData_DEVICE_COPY_OBSOLETE
UMatData_DEVICE_MEM_MAPPED
UMatData_HOST_COPY_OBSOLETE
UMatData_TEMP_COPIED_UMAT
UMatData_TEMP_UMAT
UMatData_USER_ALLOCATED
UMat_AUTO_STEP
UMat_CONTINUOUS_FLAG
UMat_DEPTH_MASK
UMat_MAGIC_MASK
UMat_MAGIC_VAL
UMat_SUBMATRIX_FLAG
UMat_TYPE_MASK
USAGE_ALLOCATE_DEVICE_MEMORY
USAGE_ALLOCATE_HOST_MEMORY
USAGE_ALLOCATE_SHARED_MEMORY
USAGE_DEFAULT
WARP_SHUFFLE_FUNCTIONS
_InputArray_CUDA_GPU_MAT
_InputArray_CUDA_HOST_MEM
_InputArray_EXPR: removed: https://github.com/opencv/opencv/pull/17046
_InputArray_FIXED_SIZE
_InputArray_FIXED_TYPE
_InputArray_KIND_MASK
_InputArray_KIND_SHIFT
_InputArray_MAT
_InputArray_MATX
_InputArray_NONE
_InputArray_OPENGL_BUFFER
_InputArray_STD_ARRAY: removed: https://github.com/opencv/opencv/issues/18897
_InputArray_STD_ARRAY_MAT
_InputArray_STD_BOOL_VECTOR
_InputArray_STD_VECTOR
_InputArray_STD_VECTOR_CUDA_GPU_MAT
_InputArray_STD_VECTOR_MAT
_InputArray_STD_VECTOR_UMAT
_InputArray_STD_VECTOR_VECTOR
_InputArray_UMAT
_OutputArray_DEPTH_MASK_8S
_OutputArray_DEPTH_MASK_8U
_OutputArray_DEPTH_MASK_16F
_OutputArray_DEPTH_MASK_16S
_OutputArray_DEPTH_MASK_16U
_OutputArray_DEPTH_MASK_32F
_OutputArray_DEPTH_MASK_32S
_OutputArray_DEPTH_MASK_64F
_OutputArray_DEPTH_MASK_ALL
_OutputArray_DEPTH_MASK_ALL_16F
_OutputArray_DEPTH_MASK_ALL_BUT_8S
_OutputArray_DEPTH_MASK_FLT
__UMAT_USAGE_FLAGS_32BIT

Traits§

AlgorithmTrait: Mutable methods for core::Algorithm
AlgorithmTraitConst: Constant methods for core::Algorithm
ArraysTrait: Mutable methods for core::Arrays
ArraysTraitConst: Constant methods for core::Arrays
AsyncArrayTrait: Mutable methods for core::AsyncArray
AsyncArrayTraitConst: Constant methods for core::AsyncArray
AsyncPromiseTrait: Mutable methods for core::AsyncPromise
AsyncPromiseTraitConst: Constant methods for core::AsyncPromise
BufferPoolTrait: Mutable methods for core::BufferPool
BufferPoolTraitConst: Constant methods for core::BufferPool
BufferTrait: Mutable methods for core::Buffer
BufferTraitConst: Constant methods for core::Buffer
CommandLineParserTrait: Mutable methods for core::CommandLineParser
CommandLineParserTraitConst: Constant methods for core::CommandLineParser
ConjGradSolverTrait: Mutable methods for core::ConjGradSolver
ConjGradSolverTraitConst: Constant methods for core::ConjGradSolver
ContextTrait: Mutable methods for core::Context
ContextTraitConst: Constant methods for core::Context
Context_UserContextTrait: Mutable methods for core::Context_UserContext
Context_UserContextTraitConst: Constant methods for core::Context_UserContext
DataType: Implement this trait types that are valid to use as Mat elements.
Detail_CheckContextTrait: Mutable methods for core::Detail_CheckContext
Detail_CheckContextTraitConst: Constant methods for core::Detail_CheckContext
DeviceInfoTrait: Mutable methods for core::DeviceInfo
DeviceInfoTraitConst: Constant methods for core::DeviceInfo
DeviceTrait: Mutable methods for core::Device
DeviceTraitConst: Constant methods for core::Device
DownhillSolverTrait: Mutable methods for core::DownhillSolver
DownhillSolverTraitConst: Constant methods for core::DownhillSolver
ElemMul: Elementwise multiplication
EventTrait: Mutable methods for core::Event
EventTraitConst: Constant methods for core::Event
ExceptionTrait: Mutable methods for core::Exception
ExceptionTraitConst: Constant methods for core::Exception
FileNodeIteratorTrait: Mutable methods for core::FileNodeIterator
FileNodeIteratorTraitConst: Constant methods for core::FileNodeIterator
FileNodeTrait: Mutable methods for core::FileNode
FileNodeTraitConst: Constant methods for core::FileNode
FileStorageTrait: Mutable methods for core::FileStorage
FileStorageTraitConst: Constant methods for core::FileStorage
FormattedTrait: Mutable methods for core::Formatted
FormattedTraitConst: Constant methods for core::Formatted
FormatterTrait: Mutable methods for core::Formatter
FormatterTraitConst: Constant methods for core::Formatter
GpuDataTrait: Mutable methods for core::GpuData
GpuDataTraitConst: Constant methods for core::GpuData
GpuMatNDTrait: Mutable methods for core::GpuMatND
GpuMatNDTraitConst: Constant methods for core::GpuMatND
GpuMatTrait: Mutable methods for core::GpuMat
GpuMatTraitConst: Constant methods for core::GpuMat
GpuMat_AllocatorTrait: Mutable methods for core::GpuMat_Allocator
GpuMat_AllocatorTraitConst: Constant methods for core::GpuMat_Allocator
HammingTrait: Mutable methods for core::Hamming
HammingTraitConst: Constant methods for core::Hamming
HostMemTrait: Mutable methods for core::HostMem
HostMemTraitConst: Constant methods for core::HostMem
ID3D10DeviceTrait
ID3D10Texture2DTrait
ID3D11DeviceTrait
ID3D11Texture2DTrait
IDirect3DDevice9ExTrait
IDirect3DDevice9Trait
IDirect3DSurface9Trait
Image2DTrait: Mutable methods for core::Image2D
Image2DTraitConst: Constant methods for core::Image2D
KernelArgTrait: Mutable methods for core::KernelArg
KernelArgTraitConst: Constant methods for core::KernelArg
KernelTrait: Mutable methods for core::Kernel
KernelTraitConst: Constant methods for core::Kernel
KeyPointTrait: Mutable methods for core::KeyPoint
KeyPointTraitConst: Constant methods for core::KeyPoint
LDATrait: Mutable methods for core::LDA
LDATraitConst: Constant methods for core::LDA
LogTagTrait: Mutable methods for core::LogTag
LogTagTraitConst: Constant methods for core::LogTag
MatConstIteratorTrait: Mutable methods for core::MatConstIterator
MatConstIteratorTraitConst: Constant methods for core::MatConstIterator
MatConstIteratorTraitManual
MatExprTrait: Mutable methods for core::MatExpr
MatExprTraitConst: Constant methods for core::MatExpr
MatOpTrait: Mutable methods for core::MatOp
MatOpTraitConst: Constant methods for core::MatOp
MatSizeTrait: Mutable methods for core::MatSize
MatSizeTraitConst: Constant methods for core::MatSize
MatStepTrait: Mutable methods for core::MatStep
MatStepTraitConst: Constant methods for core::MatStep
MatTrait: Mutable methods for core::Mat
MatTraitConst: Constant methods for core::Mat
MatTraitConstManual
MatTraitManual
MatxTrait
Matx_AddOpTrait: Mutable methods for core::Matx_AddOp
Matx_AddOpTraitConst: Constant methods for core::Matx_AddOp
Matx_DivOpTrait: Mutable methods for core::Matx_DivOp
Matx_DivOpTraitConst: Constant methods for core::Matx_DivOp
Matx_MatMulOpTrait: Mutable methods for core::Matx_MatMulOp
Matx_MatMulOpTraitConst: Constant methods for core::Matx_MatMulOp
Matx_MulOpTrait: Mutable methods for core::Matx_MulOp
Matx_MulOpTraitConst: Constant methods for core::Matx_MulOp
Matx_ScaleOpTrait: Mutable methods for core::Matx_ScaleOp
Matx_ScaleOpTraitConst: Constant methods for core::Matx_ScaleOp
Matx_SubOpTrait: Mutable methods for core::Matx_SubOp
Matx_SubOpTraitConst: Constant methods for core::Matx_SubOp
Matx_TOpTrait: Mutable methods for core::Matx_TOp
Matx_TOpTraitConst: Constant methods for core::Matx_TOp
MinProblemSolverTrait: Mutable methods for core::MinProblemSolver
MinProblemSolverTraitConst: Constant methods for core::MinProblemSolver
MinProblemSolver_FunctionTrait: Mutable methods for core::MinProblemSolver_Function
MinProblemSolver_FunctionTraitConst: Constant methods for core::MinProblemSolver_Function
ModifyInplace
NodeDataTrait: Mutable methods for core::NodeData
NodeDataTraitConst: Constant methods for core::NodeData
OpenCLExecutionContextTrait: Mutable methods for core::OpenCLExecutionContext
OpenCLExecutionContextTraitConst: Constant methods for core::OpenCLExecutionContext
OriginalClassNameTrait: Mutable methods for core::OriginalClassName
OriginalClassNameTraitConst: Constant methods for core::OriginalClassName
PCATrait: Mutable methods for core::PCA
PCATraitConst: Constant methods for core::PCA
ParallelLoopBodyTrait: Mutable methods for core::ParallelLoopBody
ParallelLoopBodyTraitConst: Constant methods for core::ParallelLoopBody
PlatformInfoTrait: Mutable methods for core::PlatformInfo
PlatformInfoTraitConst: Constant methods for core::PlatformInfo
PlatformTrait: Mutable methods for core::Platform
PlatformTraitConst: Constant methods for core::Platform
ProgramSourceTrait: Mutable methods for core::ProgramSource
ProgramSourceTraitConst: Constant methods for core::ProgramSource
ProgramTrait: Mutable methods for core::Program
ProgramTraitConst: Constant methods for core::Program
QueueTrait: Mutable methods for core::Queue
QueueTraitConst: Constant methods for core::Queue
RNGTrait: Mutable methods for core::RNG
RNGTraitConst: Constant methods for core::RNG
RNG_MT19937Trait: Mutable methods for core::RNG_MT19937
RNG_MT19937TraitConst: Constant methods for core::RNG_MT19937
RangeTrait: Mutable methods for core::Range
RangeTraitConst: Constant methods for core::Range
SVDTrait: Mutable methods for core::SVD
SVDTraitConst: Constant methods for core::SVD
SizedArray
SparseMatConstIteratorTrait: Mutable methods for core::SparseMatConstIterator
SparseMatConstIteratorTraitConst: Constant methods for core::SparseMatConstIterator
SparseMatIteratorTrait: Mutable methods for core::SparseMatIterator
SparseMatIteratorTraitConst: Constant methods for core::SparseMatIterator
SparseMatTrait: Mutable methods for core::SparseMat
SparseMatTraitConst: Constant methods for core::SparseMat
SparseMat_HdrTrait: Mutable methods for core::SparseMat_Hdr
SparseMat_HdrTraitConst: Constant methods for core::SparseMat_Hdr
SparseMat_NodeTrait: Mutable methods for core::SparseMat_Node
SparseMat_NodeTraitConst: Constant methods for core::SparseMat_Node
StreamTrait: Mutable methods for core::Stream
StreamTraitConst: Constant methods for core::Stream
TargetArchsTrait: Mutable methods for core::TargetArchs
TargetArchsTraitConst: Constant methods for core::TargetArchs
Texture2DTrait: Mutable methods for core::Texture2D
Texture2DTraitConst: Constant methods for core::Texture2D
TickMeterTrait: Mutable methods for core::TickMeter
TickMeterTraitConst: Constant methods for core::TickMeter
TimerTrait: Mutable methods for core::Timer
TimerTraitConst: Constant methods for core::Timer
ToInputArray: Trait to serve as a replacement for InputArray in C++ OpenCV
ToInputOutputArray: Trait to serve as a replacement for InputOutputArray in C++ OpenCV
ToOutputArray: Trait to serve as a replacement for OutputArray in C++ OpenCV
TupleExtern
UMatDataTrait: Mutable methods for core::UMatData
UMatDataTraitConst: Constant methods for core::UMatData
UMatTrait: Mutable methods for core::UMat
UMatTraitConst: Constant methods for core::UMat
VectorToVec
WriteStructContextTrait: Mutable methods for core::WriteStructContext
WriteStructContextTraitConst: Constant methods for core::WriteStructContext
_InputArrayTrait: Mutable methods for core::_InputArray
_InputArrayTraitConst: Constant methods for core::_InputArray
_InputOutputArrayTrait: Mutable methods for core::_InputOutputArray
_InputOutputArrayTraitConst: Constant methods for core::_InputOutputArray
_OutputArrayTrait: Mutable methods for core::_OutputArray
_OutputArrayTraitConst: Constant methods for core::_OutputArray

Functions§

CV_8SC
CV_8UC
CV_16FC
CV_16SC
CV_16UC
CV_32FC
CV_32SC
CV_64FC
CV_MAKETYPE
CV_MAKE_TYPE
CV_MAT_DEPTH
abs: Calculates an absolute value of each matrix element.
abs_matexpr: Calculates an absolute value of each matrix element.
absdiff: Calculates the per-element absolute difference between two arrays or between an array and a scalar.
add: Calculates the per-element sum of two arrays or an array and a scalar.
add_def: Calculates the per-element sum of two arrays or an array and a scalar.
add_mat_mat: @relates cv::MatExpr
add_mat_matexpr
add_mat_scalar
add_matexpr_mat
add_matexpr_matexpr
add_matexpr_scalar
add_samples_data_search_path: Override search data path by adding new search location
add_samples_data_search_sub_directory: Append samples search data sub directory
add_scalar_mat
add_scalar_matexpr
add_weighted: Calculates the weighted sum of two arrays.
add_weighted_def: Calculates the weighted sum of two arrays.
and_mat_mat
and_mat_scalar
and_scalar_mat
attach_context^⚠: Attaches OpenCL context to OpenCV
batch_distance: naive nearest neighbor finder
batch_distance_def: naive nearest neighbor finder
bitwise_and: computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
bitwise_and_def: computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
bitwise_not: Inverts every bit of an array.
bitwise_not_def: Inverts every bit of an array.
bitwise_or: Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
bitwise_or_def: Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
bitwise_xor: Calculates the per-element bit-wise “exclusive or” operation on two arrays or an array and a scalar.
bitwise_xor_def: Calculates the per-element bit-wise “exclusive or” operation on two arrays or an array and a scalar.
border_interpolate: Computes the source location of an extrapolated pixel.
broadcast: Broadcast the given Mat to the given shape.
build_options_add_matrix_description
calc_covar_matrix: Calculates the covariance matrix of a set of vectors.
calc_covar_matrix_def: @overload
cart_to_polar: Calculates the magnitude and angle of 2D vectors.
cart_to_polar_def: Calculates the magnitude and angle of 2D vectors.
check_failed_auto
check_failed_auto_1
check_failed_auto_2
check_failed_auto_3
check_failed_auto_4
check_failed_auto_5
check_failed_auto_6
check_failed_auto_7
check_failed_auto_8
check_failed_auto_9
check_failed_auto_10
check_failed_auto_11
check_failed_false
check_failed_mat_channels
check_failed_mat_channels_1
check_failed_mat_depth
check_failed_mat_depth_1
check_failed_mat_type
check_failed_mat_type_1
check_failed_true
check_hardware_support: Returns true if the specified feature is supported by the host hardware.
check_optimal_vector_width: C++ default parameters
check_optimal_vector_width_def: Note
check_range: Checks every element of an input array for invalid values.
check_range_def: Checks every element of an input array for invalid values.
cholesky: proxy for hal::Cholesky
cholesky_f32: proxy for hal::Cholesky
compare: Performs the per-element comparison of two arrays or an array and scalar value.
complete_symm: Copies the lower or the upper half of a square matrix to its another half.
complete_symm_def: Copies the lower or the upper half of a square matrix to its another half.
convert_fp16Deprecated: Converts an array to half precision floating number.
convert_from_buffer^⚠: Convert OpenCL buffer to UMat
convert_from_d3d10_texture_2d: Parameters
convert_from_d3d11_texture_2d: Parameters
convert_from_direct_3d_surface9^⚠: Parameters
convert_from_direct_3d_surface9_def: Parameters
convert_from_gl_texture_2d: Converts Texture2D object to OutputArray.
convert_from_image^⚠: Convert OpenCL image2d_t to UMat
convert_from_va_surface^⚠: Converts VASurfaceID object to OutputArray.
convert_scale_abs: Scales, calculates absolute values, and converts the result to 8-bit.
convert_scale_abs_def: Scales, calculates absolute values, and converts the result to 8-bit.
convert_to_d3d10_texture_2d: Parameters
convert_to_d3d11_texture_2d: Parameters
convert_to_direct_3d_surface9^⚠: Parameters
convert_to_direct_3d_surface9_def: Parameters
convert_to_gl_texture_2d: Converts InputArray to Texture2D object.
convert_to_va_surface^⚠: Converts InputArray to VASurfaceID object.
convert_type_str
convert_type_str_1
copy_make_border: Forms a border around an image.
copy_make_border_def: Forms a border around an image.
copy_mat_and_dump_named_arguments: C++ default parameters
copy_mat_and_dump_named_arguments_def: Note
copy_to: This is an overloaded member function, provided for convenience (python) Copies the matrix to another one. When the operation mask is specified, if the Mat::create call shown above reallocates the matrix, the newly allocated matrix is initialized with all zeros before copying the data.
count_non_zero: Counts non-zero array elements.
create_continuous: Creates a continuous matrix.
create_gpu_mat_from_cuda_memory: Bindings overload to create a GpuMat from existing GPU memory.
create_gpu_mat_from_cuda_memory_1: Bindings overload to create a GpuMat from existing GPU memory.
create_gpu_mat_from_cuda_memory_1_def: @overload
create_gpu_mat_from_cuda_memory_def: Bindings overload to create a GpuMat from existing GPU memory.
cube_root: Computes the cube root of an argument.
dct: Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
dct_def: Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
depth_to_string: Returns string of cv::Mat depth value: CV_8U -> “CV_8U” or “”
determinant: Returns the determinant of a square floating-point matrix.
device_supports: checks whether current device supports the given feature
dft: Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
dft_def: Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
div_f64_mat
div_f64_matexpr
div_mat_f64
div_mat_mat
div_mat_matexpr
div_matexpr_f64
div_matexpr_mat
div_matexpr_matexpr
divide: Performs per-element division of two arrays or a scalar by an array.
divide2: Performs per-element division of two arrays or a scalar by an array.
divide2_def: Performs per-element division of two arrays or a scalar by an array.
divide_def: @overload
dump_bool
dump_c_string
dump_double
dump_float
dump_input_array
dump_input_array_of_arrays
dump_input_output_array
dump_input_output_array_of_arrays
dump_int
dump_int64
dump_range
dump_rect
dump_rotated_rect
dump_size_t
dump_string
dump_term_criteria
dump_vec2i: C++ default parameters
dump_vec2i_def: Note
dump_vector_of_double
dump_vector_of_int
dump_vector_of_rect
eigen: Calculates eigenvalues and eigenvectors of a symmetric matrix.
eigen_def: Calculates eigenvalues and eigenvectors of a symmetric matrix.
eigen_non_symmetric: Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
ensure_size_is_enough: Ensures that the size of a matrix is big enough and the matrix has a proper type.
equals_f64_mat
equals_filenodeiterator_filenodeiterator
equals_mat_f64
equals_mat_mat
error: ! Signals an error and raises the exception.
error_1Deprecated: ! Signals an error and raises the exception.
exp: Calculates the exponent of every array element.
extract_channel: Extracts a single channel from src (coi is 0-based index)
fast_atan2: Calculates the angle of a 2D vector in degrees.
find_file: Try to find requested data file
find_file_def: Try to find requested data file
find_file_or_keep: C++ default parameters
find_file_or_keep_def: Note
find_non_zero: Returns the list of locations of non-zero pixels
finish
flip: Flips a 2D array around vertical, horizontal, or both axes.
flip_nd: Flips a n-dimensional at given axis
gemm: Performs generalized matrix multiplication.
gemm_def: Performs generalized matrix multiplication.
generate_vector_of_int
generate_vector_of_mat
generate_vector_of_rect
get_build_information: Returns full configuration time cmake output.
get_cache_directory_for_downloads
get_cpu_features_line: Returns list of CPU features enabled during compilation.
get_cpu_tick_count: Returns the number of CPU ticks.
get_cuda_enabled_device_count: Returns the number of installed CUDA-enabled devices.
get_default_algorithm_hint: ! Returns AlgorithmHint defined during OpenCV compilation. Defines ALGO_HINT_DEFAULT behavior.
get_device: Returns the current device index set by cuda::setDevice or initialized by default.
get_elem_size
get_flags
get_global_log_tag: Get global log tag
get_hardware_feature_name: Returns feature name by ID
get_ipp_error_location
get_ipp_features
get_ipp_status
get_ipp_version
get_log_level: Get global logging level
get_log_level_1
get_log_tag_level
get_num_threads: Returns the number of threads used by OpenCV for parallel regions.
get_number_of_cpus: Returns the number of logical CPUs available for the process.
get_opencl_error_string
get_optimal_dft_size: Returns the optimal DFT size for a given vector size.
get_platfoms_info
get_thread_id
get_thread_numDeprecated: Returns the index of the currently executed thread within the current parallel region. Always returns 0 if called outside of parallel region.
get_tick_count: Returns the number of ticks.
get_tick_frequency: Returns the number of ticks per second.
get_type_from_d3d_format: Get OpenCV type from DirectX type
get_type_from_dxgi_format: Get OpenCV type from DirectX type
get_version_major: Returns major library version
get_version_minor: Returns minor library version
get_version_revision: Returns revision field of the library version
get_version_string: Returns library version string
glob: Searches for files matching the specified pattern in a directory.
glob_def: Searches for files matching the specified pattern in a directory.
greater_than_f64_mat
greater_than_mat_f64
greater_than_mat_mat
greater_than_or_equal_f64_mat
greater_than_or_equal_mat_f64
greater_than_or_equal_mat_mat
has_non_zero: Checks for the presence of at least one non-zero array element.
have_amd_blas
have_amd_fft
have_opencl
have_openvx: Check if use of OpenVX is possible
have_svm
hconcat: Applies horizontal concatenation to given matrices.
hconcat2: Applies horizontal concatenation to given matrices.
idct: Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
idct_def: Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
idft: Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
idft_def: Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
in_range: Checks if array elements lie between the elements of two other arrays.
initialize_context_from_d3d10_device: Parameters
initialize_context_from_d3d11_device: Parameters
initialize_context_from_direct_3d_device9: Parameters
initialize_context_from_direct_3d_device9_ex: Parameters
initialize_context_from_gl: Creates OpenCL context from GL.
initialize_context_from_va^⚠: Creates OpenCL context from VA.
initialize_context_from_va_def^⚠: Creates OpenCL context from VA.
insert_channel: Inserts a single channel to dst (coi is 0-based index)
invert: Finds the inverse or pseudo-inverse of a matrix.
invert_def: Finds the inverse or pseudo-inverse of a matrix.
kernel_to_str: C++ default parameters
kernel_to_str_def: Note
kmeans: Finds centers of clusters and groups input samples around the clusters.
kmeans_def: Finds centers of clusters and groups input samples around the clusters.
less_than_f64_mat
less_than_mat_f64
less_than_mat_mat
less_than_or_equal_f64_mat
less_than_or_equal_mat_f64
less_than_or_equal_mat_mat
log: Calculates the natural logarithm of every array element.
lu: proxy for hal::LU
lu_f32: proxy for hal::LU
lut: Performs a look-up table transform of an array.
magnitude: Calculates the magnitude of 2D vectors.
mahalanobis: Calculates the Mahalanobis distance between two vectors.
map_gl_buffer: Maps Buffer object to process on CL side (convert to UMat).
map_gl_buffer_def: Maps Buffer object to process on CL side (convert to UMat).
max: Calculates per-element maximum of two arrays or an array and a scalar.
max_f64_mat
max_mat
max_mat_f64
max_mat_to: Calculates per-element maximum of two arrays or an array and a scalar.
max_umat_to: Calculates per-element maximum of two arrays or an array and a scalar.
mean: Calculates an average (mean) of array elements.
mean_def: Calculates an average (mean) of array elements.
mean_std_dev: Calculates a mean and standard deviation of array elements.
mean_std_dev_def: Calculates a mean and standard deviation of array elements.
memop_type_to_str
merge: Creates one multi-channel array out of several single-channel ones.
min: Calculates per-element minimum of two arrays or an array and a scalar.
min_f64_mat
min_mat
min_mat_f64
min_mat_to: Calculates per-element minimum of two arrays or an array and a scalar.
min_max_idx: Finds the global minimum and maximum in an array
min_max_idx_def: Finds the global minimum and maximum in an array
min_max_loc: Finds the global minimum and maximum in an array.
min_max_loc_def: Finds the global minimum and maximum in an array.
min_max_loc_sparse: Finds the global minimum and maximum in an array.
min_max_loc_sparse_def: @overload
min_umat_to: Calculates per-element minimum of two arrays or an array and a scalar.
mix_channels: Copies specified channels from input arrays to the specified channels of output arrays.
mix_channels_vec: Copies specified channels from input arrays to the specified channels of output arrays.
mul_f64_mat
mul_f64_matexpr
mul_mat_f64
mul_mat_mat
mul_mat_matexpr
mul_matexpr_f64
mul_matexpr_mat
mul_matexpr_matexpr
mul_spectrums: Performs the per-element multiplication of two Fourier spectrums.
mul_spectrums_def: Performs the per-element multiplication of two Fourier spectrums.
mul_transposed: Calculates the product of a matrix and its transposition.
mul_transposed_def: Calculates the product of a matrix and its transposition.
multiply: Calculates the per-element scaled product of two arrays.
multiply_def: Calculates the per-element scaled product of two arrays.
negate
no_array: Returns an empty InputArray or OutputArray.
norm: Calculates the absolute norm of an array.
norm2: Calculates an absolute difference norm or a relative difference norm.
norm2_def: Calculates an absolute difference norm or a relative difference norm.
norm_def: Calculates the absolute norm of an array.
norm_sparse: Calculates an absolute difference norm or a relative difference norm.
normalize: Normalizes the norm or value range of an array.
normalize_def: Normalizes the norm or value range of an array.
normalize_sparse: Normalizes the norm or value range of an array.
not_equals_f64_mat
not_equals_filenodeiterator_filenodeiterator
not_equals_mat_f64
not_equals_mat_mat
or_mat_mat
or_mat_scalar
or_scalar_mat
parallel_for_: Parallel data processor
parallel_for__def: Parallel data processor
patch_na_ns: Replaces NaNs by given number
patch_na_ns_def: Replaces NaNs by given number
pca_back_project: wrap PCA::backProject
pca_compute: wrap PCA::operator()
pca_compute2: wrap PCA::operator() and add eigenvalues output parameter
pca_compute2_def: wrap PCA::operator() and add eigenvalues output parameter
pca_compute2_variance: wrap PCA::operator() and add eigenvalues output parameter
pca_compute_def: wrap PCA::operator()
pca_compute_variance: wrap PCA::operator()
pca_project: wrap PCA::project
perspective_transform: Performs the perspective matrix transformation of vectors.
phase: Calculates the rotation angle of 2D vectors.
phase_def: Calculates the rotation angle of 2D vectors.
polar_to_cart: Calculates x and y coordinates of 2D vectors from their magnitude and angle.
polar_to_cart_def: Calculates x and y coordinates of 2D vectors from their magnitude and angle.
pow: Raises every array element to a power.
predict_optimal_vector_width: C++ default parameters
predict_optimal_vector_width_def: Note
predict_optimal_vector_width_max: C++ default parameters
predict_optimal_vector_width_max_def: Note
print_cuda_device_info
print_short_cuda_device_info
psnr: Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
psnr_def: Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
rand_shuffle: Shuffles the array elements randomly.
rand_shuffle_def: Shuffles the array elements randomly.
randn: Fills the array with normally distributed random numbers.
randu: Generates a single uniformly-distributed random number or an array of random numbers.
read
read_dmatch
read_dmatch_vec_legacy
read_f32
read_f64
read_i32
read_keypoint
read_keypoint_vec_legacy
read_mat: C++ default parameters
read_mat_def: Note
read_sparsemat: C++ default parameters
read_sparsemat_def: Note
read_str
rectangle_intersection_area: Finds out if there is any intersection between two rectangles
reduce: Reduces a matrix to a vector.
reduce_arg_max: Finds indices of max elements along provided axis
reduce_arg_max_def: Finds indices of max elements along provided axis
reduce_arg_min: Finds indices of min elements along provided axis
reduce_arg_min_def: Finds indices of min elements along provided axis
reduce_def: Reduces a matrix to a vector.
register_log_tag
register_page_locked: Page-locks the memory of matrix and maps it for the device(s).
render: Render OpenGL texture or primitives.
render_1: Render OpenGL texture or primitives.
render_2: Render OpenGL texture or primitives.
render_1_def: @overload
render_2_def: @overload
render_def: Render OpenGL texture or primitives.
repeat: Fills the output array with repeated copies of the input array.
repeat_to: Fills the output array with repeated copies of the input array.
reset_device: Explicitly destroys and cleans up all resources associated with the current device in the current process.
reset_trace
rotate: Rotates a 2D array in multiples of 90 degrees. The function cv::rotate rotates the array in one of three different ways:
scale_add: Calculates the sum of a scaled array and another array.
set_break_on_error: Sets/resets the break-on-error mode.
set_buffer_pool_config
set_buffer_pool_usage: BufferPool management (must be called before Stream creation)
set_device: Sets a device and initializes it for the current thread.
set_flags
set_gl_device: Sets a CUDA device and initializes it for the current thread with OpenGL interoperability.
set_gl_device_def: Sets a CUDA device and initializes it for the current thread with OpenGL interoperability.
set_identity: Initializes a scaled identity matrix.
set_identity_def: Initializes a scaled identity matrix.
set_ipp_status: C++ default parameters
set_ipp_status_def: Note
set_log_level: Set global logging level
set_log_level_1: @cond IGNORED
set_log_tag_level
set_num_threads: OpenCV will try to set the number of threads for subsequent parallel regions.
set_rng_seed: Sets state of default random number generator.
set_use_instrumentation
set_use_ipp
set_use_ipp_not_exact
set_use_opencl
set_use_openvx: Enable/disable use of OpenVX
set_use_optimized: Enables or disables the optimized code.
solve: Solves one or more linear systems or least-squares problems.
solve_cubic: Finds the real roots of a cubic equation.
solve_def: Solves one or more linear systems or least-squares problems.
solve_lp: Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
solve_lp_1: Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
solve_poly: Finds the real or complex roots of a polynomial equation.
solve_poly_def: Finds the real or complex roots of a polynomial equation.
sort: Sorts each row or each column of a matrix.
sort_idx: Sorts each row or each column of a matrix.
split: Divides a multi-channel array into several single-channel arrays.
split_slice: Divides a multi-channel array into several single-channel arrays.
sqrt: Calculates a square root of array elements.
sub_mat
sub_mat_mat
sub_mat_matexpr
sub_mat_scalar
sub_matexpr
sub_matexpr_mat
sub_matexpr_matexpr
sub_matexpr_scalar
sub_scalar_mat
sub_scalar_matexpr
subtract: Calculates the per-element difference between two arrays or array and a scalar.
subtract_def: Calculates the per-element difference between two arrays or array and a scalar.
sum_elems: Calculates the sum of array elements.
sv_back_subst: wrap SVD::backSubst
sv_decomp: wrap SVD::compute
sv_decomp_def: wrap SVD::compute
swap: Swaps two matrices
swap_umat: Swaps two matrices
tempfile: Generates a unique temporary file name.
tempfile_def: Generates a unique temporary file name.
terminate: ! Signals an error and terminate application.
test_async_array
test_async_exception
test_echo_boolean_function
test_overload_resolution: @cond IGNORED
test_overload_resolution_1
test_overload_resolution_def: @cond IGNORED
test_overwrite_native_method
test_raise_general_exception
test_reserved_keyword_conversion: C++ default parameters
test_reserved_keyword_conversion_def: Note
test_rotated_rect
test_rotated_rect_vector
the_rng: Returns the default random number generator.
trace: Returns the trace of a matrix.
transform: Performs the matrix transformation of every array element.
transpose: Transposes a matrix.
transpose_nd: Transpose for n-dimensional matrices.
type_to_str
type_to_string: Returns string of cv::Mat depth value: CV_8UC3 -> “CV_8UC3” or “”
unmap_gl_buffer: Unmaps Buffer object (releases UMat, previously mapped from Buffer).
unregister_page_locked: Unmaps the memory of matrix and makes it pageable again.
use_instrumentation
use_ipp
use_ipp_not_exact
use_opencl
use_openvx: Check if use of OpenVX is enabled
use_optimized: Returns the status of optimized code usage.
vconcat: Applies vertical concatenation to given matrices.
vconcat2: Applies vertical concatenation to given matrices.
vecop_type_to_str
wrap_stream: Bindings overload to create a Stream object from the address stored in an existing CUDA Runtime API stream pointer (cudaStream_t).
write
write_dmatch_vec
write_f32
write_f64
write_i32: //////////////// XML & YAML I/O implementation //////////////////
write_keypoint_vec
write_log_message: Write log message
write_log_message_ex: Write log message
write_mat
write_scalar
write_scalar_f32
write_scalar_f64
write_scalar_i32
write_scalar_str
write_sparsemat
write_str
xor_mat_mat
xor_mat_scalar
xor_scalar_mat

Type Aliases§

Affine3d
Affine3f
GpuMatND_IndexArray
GpuMatND_SizeArray
GpuMatND_StepArray
HammingLUT
Hamming_ResultType
Hamming_ValueType
InputArray
InputArrayOfArrays
InputOutputArray
InputOutputArrayOfArrays
Mat1b
Mat1d
Mat1f
Mat1i
Mat1s
Mat1w
Mat2b
Mat2d
Mat2f
Mat2i
Mat2s
Mat2w
Mat3b
Mat3d
Mat3f
Mat3i
Mat3s
Mat3w
Mat4b
Mat4d
Mat4f
Mat4i
Mat4s
Mat4w
MatConstIterator_difference_type
MatConstIterator_pointer
MatConstIterator_reference
MatConstIterator_value_type
MatND
Matx12
Matx13
Matx14
Matx16
Matx21
Matx22
Matx23
Matx31
Matx32
Matx33
Matx34
Matx41
Matx43
Matx44
Matx61
Matx66
Matx12d
Matx12f
Matx13d
Matx13f
Matx14d
Matx14f
Matx16d
Matx16f
Matx21d
Matx21f
Matx22d
Matx22f
Matx23d
Matx23f
Matx31d
Matx31f
Matx32d
Matx32f
Matx33d
Matx33f
Matx34d
Matx34f
Matx41d
Matx41f
Matx43d
Matx43f
Matx44d
Matx44f
Matx61d
Matx61f
Matx66d
Matx66f
OutputArray
OutputArrayOfArrays
Point
Point2d
Point2f
Point2i
Point2l
Point3d
Point3f
Point3i
ProgramSource_hash_t
Rect
Rect2d
Rect2f
Rect2i
Scalar
Scalar_: docs.opencv.org
Size
Size2d
Size2f
Size2i
Size2l
SparseMat_const_iterator
SparseMat_iterator
Stream_StreamCallback
VADisplay
VASurfaceID
Vec2b: Shorter aliases for the most popular specializations of Vec<T,n>
Vec2d
Vec2f
Vec2i
Vec2s
Vec2w
Vec3b
Vec3d
Vec3f
Vec3i
Vec3s
Vec3w
Vec4b
Vec4d
Vec4f
Vec4i
Vec4s
Vec4w
Vec6d
Vec6f
Vec6i
Vec8i
float16_t

Module coreCopy item path