[−][src]Module opencv::core
Core functionality
Basic structures
C structures and operations
Operations on arrays
Asynchronous API
XML/YAML Persistence
Clustering
Utility and system functions and macros
OpenGL interoperability
Intel IPP Asynchronous C/C++ Converters
Optimization Algorithms
DirectX interoperability
Eigen support
OpenCL support
Intel VA-API/OpenCL (CL-VA) interoperability
Hardware Acceleration Layer
Modules
| prelude |
Structs
| Affine3 | |
| Algorithm | This is a base class for all more or less complex algorithms in OpenCV |
| Array66 | |
| 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 |
| CommandLineParser | Designed for command line parsing |
| Context | |
| DMatch | Class for matching keypoint descriptors |
| Detail_CheckContext | |
| Device | |
| DeviceInfo | Class providing functionality for querying the specified GPU properties. |
| 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. |
| GpuMat | Base storage class for GPU memory with reference counting. |
| 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 )): |
| MatSize | |
| MatStep | |
| Mat_ | |
| Matx | |
| Matx_AddOp | @cond IGNORED |
| Matx_DivOp | |
| Matx_MatMulOp | |
| Matx_MulOp | |
| Matx_ScaleOp | |
| Matx_SubOp | |
| Matx_TOp | |
| Moments | struct returned by cv::moments |
| NodeData | |
| PCA | Principal Component Analysis |
| Platform | |
| PlatformInfo | |
| Point3_ | |
| Point_ | |
| Program | |
| ProgramSource | |
| Ptr | |
| Queue | |
| RNG | Random Number Generator |
| RNG_MT19937 | Mersenne Twister random number generator |
| Range | Template class specifying a continuous subsequence (slice) of a sequence. |
| Rect_ | |
| RotatedRect | The class represents rotated (i.e. not up-right) rectangles on a plane. |
| SVD | Singular Value Decomposition |
| Scalar_ | |
| Size_ | |
| 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 | |
| UMat | @todo document |
| UMatData | |
| Vec2 | |
| Vec3 | |
| Vec4 | |
| Vec6 | |
| Vec8 | |
| Vec18 | |
| 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. |
Enums
| AccessFlag | |
| 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 |
| 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 | |
| BORDER_CONSTANT |
|
| BORDER_DEFAULT | same as BORDER_REFLECT_101 |
| BORDER_ISOLATED | do not look outside of ROI |
| BORDER_REFLECT |
|
| BORDER_REFLECT101 | same as BORDER_REFLECT_101 |
| BORDER_REFLECT_101 |
|
| BORDER_REPLICATE |
|
| BORDER_TRANSPARENT |
|
| BORDER_WRAP |
|
| 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 | |
| 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_MAX_FEATURE | |
| CPU_MMX | |
| CPU_MSA | |
| CPU_NEON | |
| CPU_POPCNT | |
| 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_MMX | |
| CV_CPU_MSA | |
| CV_CPU_NEON | |
| CV_CPU_NONE | |
| CV_CPU_POPCNT | |
| 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_CXX_MOVE_SEMANTICS | |
| CV_CXX_STD_ARRAY | |
| 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_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_MAJOR_VERSION | |
| CV_MAT_CN_MASK | |
| CV_MAT_CONT_FLAG | |
| CV_MAT_CONT_FLAG_SHIFT | |
| CV_MAT_DEPTH_MASK | |
| CV_MAT_TYPE_MASK | |
| CV_MINOR_VERSION | |
| CV_MMX | |
| CV_MSA | |
| CV_NEON | |
| CV_PI | |
| CV_POPCNT | |
| 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 systeminline 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 | |
| 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 | |
| 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 |
| 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 |
| 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 |
| 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. |
| 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_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 |
| 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 | |
| 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 | |
| __UMAT_USAGE_FLAGS_32BIT |
Traits
| AlgorithmTrait | This is a base class for all more or less complex algorithms in OpenCV |
| ArraysTrait | Wrapper for OpenGL Client-Side Vertex arrays. |
| AsyncArrayTrait | Returns result of asynchronous operations |
| AsyncPromiseTrait | Provides result of asynchronous operations |
| BufferPoolTrait | BufferPool for use with CUDA streams |
| BufferTrait | Smart pointer for OpenGL buffer object with reference counting. |
| CommandLineParserTrait | Designed for command line parsing |
| ConjGradSolver | This class is used to perform the non-linear non-constrained minimization of a function with known gradient, |
| ContextTrait | |
| DataType | This sealed trait is implemented for types that are valid to use as Mat elements |
| Detail_CheckContextTrait | |
| DeviceInfoTrait | Class providing functionality for querying the specified GPU properties. |
| DeviceTrait | |
| DownhillSolver | This class is used to perform the non-linear non-constrained minimization of a function, |
| EventTrait | |
| ExceptionTrait | ! Class passed to an error. |
| FileNodeIteratorTrait | used to iterate through sequences and mappings. |
| FileNodeTrait | File Storage Node class. |
| FileStorageTrait | 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 |
| GpuMatTrait | Base storage class for GPU memory with reference counting. |
| GpuMat_Allocator | |
| HammingTrait | |
| HostMemTrait | Class with reference counting wrapping special memory type allocation functions from CUDA. |
| Image2DTrait | |
| KernelArgTrait | |
| KernelTrait | |
| LDATrait | Linear Discriminant Analysis @todo document this class |
| LogTagTrait | |
| MatConstIteratorTrait | /////////////////////////////// MatConstIterator ////////////////////////////////// |
| MatConstIteratorTraitManual | |
| MatExprTrait | 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 )): |
| MatOp | ////////////////////////////// Matrix Expressions ///////////////////////////////// |
| MatSizeTrait | |
| MatStepTrait | |
| MatTrait | n-dimensional dense array class \anchor CVMat_Details |
| MatTraitManual | |
| MatxTrait | |
| Matx_AddOpTrait | @cond IGNORED |
| Matx_DivOpTrait | |
| Matx_MatMulOpTrait | |
| Matx_MulOpTrait | |
| Matx_ScaleOpTrait | |
| Matx_SubOpTrait | |
| Matx_TOpTrait | |
| MinProblemSolver | Basic interface for all solvers |
| MinProblemSolver_Function | Represents function being optimized |
| NodeDataTrait | |
| PCATrait | Principal Component Analysis |
| ParallelLoopBody | Base class for parallel data processors |
| PlatformInfoTrait | |
| PlatformTrait | |
| ProgramSourceTrait | |
| ProgramTrait | |
| QueueTrait | |
| RNGTrait | Random Number Generator |
| RNG_MT19937Trait | Mersenne Twister random number generator |
| RangeTrait | Template class specifying a continuous subsequence (slice) of a sequence. |
| RotatedRectTrait | The class represents rotated (i.e. not up-right) rectangles on a plane. |
| SVDTrait | Singular Value Decomposition |
| SizedArray | |
| SparseMatConstIteratorTrait | Read-Only Sparse Matrix Iterator. |
| SparseMatIteratorTrait | Read-write Sparse Matrix Iterator |
| SparseMatTrait | The class SparseMat represents multi-dimensional sparse numerical arrays. |
| SparseMat_HdrTrait | the sparse matrix header |
| SparseMat_NodeTrait | sparse matrix node - element of a hash table |
| StreamTrait | This class encapsulates a queue of asynchronous calls. |
| TLSDataContainer | TLS container base implementation |
| TargetArchsTrait | Class providing a set of static methods to check what NVIDIA* card architecture the CUDA module was built for. |
| Texture2DTrait | Smart pointer for OpenGL 2D texture memory with reference counting. |
| TickMeterTrait | a Class to measure passing time. |
| TimerTrait | |
| ToInputArray | Trait to serve as a replacement for |
| ToInputOutputArray | Trait to serve as a replacement for |
| ToOutputArray | Trait to serve as a replacement for |
| UMatDataTrait | |
| UMatTrait | @todo document |
| UMatTraitManual | |
| ValidMatxType | This sealed trait is implemented for types that are valid to use in corresponding context |
| ValidPoint3Type | This sealed trait is implemented for types that are valid to use in corresponding context |
| ValidPointType | This sealed trait is implemented for types that are valid to use in corresponding context |
| ValidRectType | This sealed trait is implemented for types that are valid to use in corresponding context |
| ValidScalarType | This sealed trait is implemented for types that are valid to use in corresponding context |
| ValidSizeType | This sealed trait is implemented for types that are valid to use in corresponding context |
| ValidVecType | This sealed trait is implemented for types that are valid to use in corresponding context |
| VectorElement | This trait is implemented by any type that can be stored inside |
| WriteStructContextTrait | |
| _InputArrayTrait | This is the proxy class for passing read-only input arrays into OpenCV functions. |
| _InputOutputArrayTrait | |
| _OutputArrayTrait | This type is very similar to InputArray except that it is used for input/output and output function parameters. |
Functions
| 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_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. |
| attach_context | Attaches OpenCL context to OpenCV |
| batch_distance | 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_not | 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_xor | 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. |
| build_options_add_matrix_description | |
| calc_covar_matrix | Calculates the covariance matrix of a set of vectors. |
| cart_to_polar | 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_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_hardware_support | Returns true if the specified feature is supported by the host hardware. |
| check_optimal_vector_width | C++ default parameters |
| check_range | 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. |
| convert_fp16 | Converts an array to half precision floating number. |
| convert_from_buffer | Convert OpenCL buffer to UMat |
| 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_to_gl_texture_2d | Converts InputArray to Texture2D object. |
| convert_to_va_surface | Converts InputArray to VASurfaceID object. |
| convert_type_str | |
| copy_make_border | Forms a border around an image. |
| 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. |
| cube_root | Computes the cube root of an argument. |
| dct | 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. |
| 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. |
| 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_size_t | |
| eigen | 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. |
| error | ! Signals an error and raises the exception. |
| error_1 | Deprecated ! 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_or_keep | C++ default parameters |
| find_non_zero | Returns the list of locations of non-zero pixels |
| finish | |
| flip | Flips a 2D array around vertical, horizontal, or both axes. |
| gemm | Performs generalized matrix multiplication. |
| get_build_information | Returns full configuration time cmake output. |
| 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_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_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_num | Deprecated 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 | C++ default parameters |
| 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. |
| idft | 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_gl | Creates OpenCL context from GL. |
| initialize_context_from_va | 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. |
| kernel_to_str | C++ default parameters |
| kmeans | Finds centers of clusters and groups input samples around the clusters. |
| 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). |
| 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_std_dev | 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. |
| merge_slice | 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_loc | Finds the global minimum and maximum in an array. |
| min_max_loc_sparse | Finds the global minimum and maximum in an array. |
| 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_transposed | Calculates the product of a matrix and its transposition. |
| multiply | Calculates the per-element scaled product of two arrays. |
| no_array | |
| norm | Calculates the absolute norm of an array. |
| norm2 | Calculates an absolute difference norm or a relative difference norm. |
| norm_sparse | Calculates an absolute difference norm or a relative difference norm. |
| normalize | Normalizes the norm or value range of an array. |
| normalize_sparse | Normalizes the norm or value range of an array. |
| parallel_for_ | Parallel data processor |
| patch_na_ns | converts NaN's to the 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_variance | wrap PCA::operator() and add eigenvalues output parameter |
| 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. |
| polar_to_cart | 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_max | C++ default parameters |
| print_cuda_device_info | |
| print_short_cuda_device_info | |
| psnr | Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric. |
| rand_shuffle | 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_dmatch | |
| read_dmatch_vec_legacy | |
| read_f32 | |
| read_f64 | |
| read_i32 | @relates cv::FileNode |
| read_keypoint | |
| read_keypoint_vec_legacy | |
| read_mat | C++ default parameters |
| read_sparsemat | C++ default parameters |
| read_str | |
| reduce | 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. |
| 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_identity | Initializes a scaled identity matrix. |
| set_ipp_status | C++ default parameters |
| set_log_level | Set global logging level |
| set_log_tag_level | |
| set_num_threads | OpenCV will try to set the number of threads for the next parallel region. |
| 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_lp | 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. |
| 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. |
| sum_elems | Calculates the sum of array elements. |
| sv_back_subst | wrap SVD::backSubst |
| sv_decomp | wrap SVD::compute |
| swap | Swaps two matrices |
| swap_umat | Swaps two matrices |
| tempfile | C++ default parameters |
| test_async_array | |
| test_async_exception | |
| 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. |
| 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 | |
| write_dmatch_vec | |
| write_f32 | |
| write_f64 | |
| write_i32 | @relates cv::FileStorage |
| write_keypoint_vec | |
| write_log_message | Write log message |
| write_log_message_ex | Write log message |
| write_mat | |
| write_scalar_f32 | |
| write_scalar_f64 | |
| write_scalar_i32 | |
| write_scalar_str | |
| write_sparsemat | |
| write_str |