| Class | Description |
|---|---|
| AbstractArray | |
| AbstractCvBox2D | |
| AbstractCvFont | |
| AbstractCvGraph | |
| AbstractCvGraphScanner | |
| AbstractCvGraphScanner.ReleaseDeallocator | |
| AbstractCvMat | |
| AbstractCvMat.ReleaseDeallocator | |
| AbstractCvMatND | |
| AbstractCvMatND.ReleaseDeallocator | |
| AbstractCvMemStorage | |
| AbstractCvMemStorage.ReleaseDeallocator | |
| AbstractCvPoint | |
| AbstractCvPoint2D32f | |
| AbstractCvPoint2D64f | |
| AbstractCvPoint3D32f | |
| AbstractCvPoint3D64f | |
| AbstractCvRect | |
| AbstractCvScalar | |
| AbstractCvSeq | |
| AbstractCvSet | |
| AbstractCvSize | |
| AbstractCvSize2D32f | |
| AbstractCvSparseMat | |
| AbstractCvSparseMat.ReleaseDeallocator | |
| AbstractIplImage | |
| AbstractIplImage.HeaderReleaseDeallocator | |
| AbstractIplImage.ReleaseDeallocator | |
| AbstractMat | |
| AbstractScalar | |
| Algorithm |
\brief This is a base class for all more or less complex algorithms in OpenCV
especially for classes of algorithms, for which there can be multiple implementations.
|
| Arrays | |
| AsyncArray |
\brief Returns result of asynchronous operations
Object has attached asynchronous state.
|
| AutoLock | |
| Buffer | |
| BufferPool |
\brief BufferPool for use with CUDA streams
BufferPool utilizes Stream's allocator to create new buffers for GpuMat's.
|
| BufferPoolController |
\addtogroup core_opencl
\{
|
| ByteVectorVector | |
| Complexd | |
| Complexf |
\addtogroup core_basic
\{
//////////////////////////////// Complex //////////////////////////////
/** \brief A complex number class.
|
| ConjGradSolver |
\brief This class is used to perform the non-linear non-constrained minimization of a function
with known gradient,
defined on an *n*-dimensional Euclidean space, using the **Nonlinear Conjugate Gradient method**.
|
| Context | |
| Context.Impl | |
| Context.UserContext | |
| Cv_iplAllocateImageData | |
| Cv_iplCloneImage | |
| Cv_iplCreateImageHeader | |
| Cv_iplCreateROI | |
| Cv_iplDeallocate | |
| Cv16suf | |
| Cv32suf | |
| Cv64suf | |
| CvArr | |
| CvArrArray | |
| CvBox2D | |
| CvChain |
Chain/Contour
|
| CvCmpFunc |
a < b ?
|
| CvContour | |
| CvErrorCallback | |
| CvGraph | |
| CvGraphEdge | |
| CvGraphScanner | |
| CvGraphVtx | |
| CvGraphVtx2D | |
| CvHistogram | |
| CvLineIterator |
Line iterator state:
|
| CvMat | Deprecated
CvMat is now obsolete; consider using Mat instead.
|
| CvMatArray | |
| CvMatND | Deprecated
consider using cv::Mat instead
|
| CvMatNDArray | |
| CvMemBlock |
Memory storage
|
| CvMemStorage | |
| CvMemStoragePos | |
| CvNArrayIterator |
matrix iterator: used for n-ary operations on dense arrays
|
| CvPoint |
CvPoint and variants
|
| CvPoint2D32f | |
| CvPoint2D64f | |
| CvPoint3D32f | |
| CvPoint3D64f | |
| CvRect | |
| CvScalar | |
| CvSeq | |
| CvSeqBlock |
Sequence
|
| CvSeqReader | |
| CvSeqWriter | |
| CvSet | |
| CvSetElem | |
| CvSize |
CvSize's & CvBox
|
| CvSize2D32f | |
| CvSlice | |
| CvSparseMat | |
| CvSparseMatIterator | |
| CvSparseNode |
iteration through a sparse array
|
| CvTermCriteria | |
| CvTreeNodeIterator |
Iteration through the sequence tree
|
| DCT2D | |
| Device | |
| Device.Impl | |
| DeviceInfo |
\brief Class providing functionality for querying the specified GPU properties.
|
| DFT1D | |
| DFT2D | |
| DMatch |
\brief Class for matching keypoint descriptors
query descriptor index, train descriptor index, train image index, and distance between
descriptors.
|
| DMatchVector | |
| DMatchVector.Iterator | |
| DMatchVectorVector | |
| DMatchVectorVector.Iterator | |
| DownhillSolver |
\brief This class is used to perform the non-linear non-constrained minimization of a function,
defined on an
n-dimensional Euclidean space, using the **Nelder-Mead method**, also known as
downhill simplex method**. |
| ErrorCallback | |
| Event | |
| Event.Impl | |
| FileNode |
\brief File Storage Node class.
|
| FileNodeIterator |
\brief used to iterate through sequences and mappings.
|
| FileStorage |
\brief XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or
reading data to/from a file.
|
| FloatVectorVector | |
| Formatted |
\} core_cluster
\addtogroup core_basic
\{
/////////////////////////////// Formatted output of cv::Mat ///////////////////////////
/** \todo document
|
| Formatter |
\todo document
|
| GpuData | |
| GpuMat |
\brief Base storage class for GPU memory with reference counting.
|
| GpuMat.Allocator | |
| GpuMatND | |
| GpuMatVector | |
| GpuMatVector.Iterator | |
| Hamming | |
| hfloat | |
| HostMem |
\brief Class with reference counting wrapping special memory type allocation functions from CUDA.
|
| Image2D | |
| InstrNode |
\endcond
|
| IntDoubleMap | |
| IntDoubleMap.Iterator | |
| IntDoublePairVector | |
| IntIntPair | |
| IntIntPairVector | |
| IntVectorVector | |
| IplConvKernel | |
| IplConvKernelFP | |
| IplImage |
The IplImage is taken from the Intel Image Processing Library, in which the format is native.
|
| IplImageArray | |
| IplROI | |
| IplTileInfo | |
| Kernel | |
| Kernel.Impl | |
| KernelArg | |
| KeyPoint |
\brief Data structure for salient point detectors.
|
| KeyPointVector | |
| KeyPointVector.Iterator | |
| KeyPointVectorVector | |
| KeyPointVectorVector.Iterator | |
| LDA |
\brief Linear Discriminant Analysis
\todo document this class
|
| Mat |
\brief n-dimensional dense array class \anchor CVMat_Details
The class Mat represents an n-dimensional dense numerical single-channel or multi-channel array.
|
| MatAllocator |
\brief Custom array allocator
|
| MatBytePairVector | |
| MatConstIterator | |
| MatExpr |
\brief 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 ( cv::Mat ), s for a cv::Scalar, alpha for a
real-valued scalar ( double )):
- Addition, subtraction, negation:
A+B, A-B, A+s, A-s, s+A, s-A, -A
- Scaling: A*alpha
- Per-element multiplication and division: A.mul(B), A/B, alpha/A
- Matrix multiplication: A*B
- Transposition: A.t() (means AT)
- Matrix inversion and pseudo-inversion, solving linear systems and least-squares problems:
A.inv([method]) (~ A<sup>-1</sup>), A.inv([method])*B (~ X: AX=B)
- Comparison: A cmpop B, A cmpop alpha, alpha cmpop A, where *cmpop* is one of
>, >=, ==, {@code ! |
| MatOp | |
| MatSize | |
| MatStep | |
| MatVector | |
| MatVector.Iterator | |
| MatVectorVector | |
| MatVectorVector.Iterator | |
| MinProblemSolver |
\brief Basic interface for all solvers
|
| MinProblemSolver.Function |
\brief Represents function being optimized
|
| Moments |
\} core_basic
///////////////////////// raster image moments //////////////////////////
\addtogroup imgproc_shape
\{
/** \brief struct returned by cv::moments
The spatial moments
\texttt{Moments::m}_{ji} are computed as:
\[\texttt{m} _{ji}= \sum _{x,y} \left ( \texttt{array} (x,y) \cdot x^j \cdot y^i \right )\]
The central moments \texttt{Moments::mu}_{ji} are computed as:
\[\texttt{mu} _{ji}= \sum _{x,y} \left ( \texttt{array} (x,y) \cdot (x - \bar{x} )^j \cdot (y - \bar{y} )^i \right )\]
where (\bar{x}, \bar{y}) is the mass center:
\[\bar{x} = \frac{\texttt{m}_{10}}{\texttt{m}_{00}} , \; \bar{y} = \frac{\texttt{m}_{01}}{\texttt{m}_{00}}\]
The normalized central moments \texttt{Moments::nu}_{ij} are computed as:
\[\texttt{nu} _{ji}= \frac{\texttt{mu}_{ji}}{\texttt{m}_{00}^{(i+j)/2+1}} .\]
\note
\texttt{mu}_{00}=\texttt{m}_{00}, \texttt{nu}_{00}=1
\texttt{nu}_{10}=\texttt{mu}_{10}=\texttt{mu}_{01}=\texttt{mu}_{10}=0 , hence the values are not
stored. |
| Mutex | |
| NAryMatIterator |
\brief n-ary multi-dimensional array iterator.
|
| NodeData | |
| NodeDataTls | |
| NodeDataTlsData |
\brief Simple TLS data class
|
| NodeDataTlsVector | |
| NodeDataTlsVector.Iterator | |
| OclPlatform | Deprecated |
| OclPlatform.Impl | |
| OpenCLExecutionContext | |
| OpenCLExecutionContext.Impl | |
| OpenCLExecutionContextScope | |
| ParallelLoopBody |
\brief Base class for parallel data processors
\ingroup core_parallel
|
| ParallelLoopBodyLambdaWrapper |
\ingroup core_parallel
|
| PCA |
\brief Principal Component Analysis
The class is used to calculate a special basis for a set of vectors.
|
| PlatformInfo | |
| PlatformInfo.Impl | |
| Point |
\brief Template class for 2D points specified by its coordinates
x and y. |
| Point2d | |
| Point2dVector | |
| Point2dVector.Iterator | |
| Point2dVectorVector | |
| Point2dVectorVector.Iterator | |
| Point2f | |
| Point2fVector | |
| Point2fVector.Iterator | |
| Point2fVectorVector | |
| Point2fVectorVector.Iterator | |
| Point3d | |
| Point3f | |
| Point3fVector | |
| Point3fVector.Iterator | |
| Point3fVectorVector | |
| Point3fVectorVector.Iterator | |
| Point3i |
\brief Template class for 3D points specified by its coordinates
x, y and z. |
| Point3iVector | |
| Point3iVector.Iterator | |
| PointVector | |
| PointVector.Iterator | |
| PointVectorVector | |
| PointVectorVector.Iterator | |
| Program | |
| ProgramSource | |
| Queue | |
| Range |
\brief Template class specifying a continuous subsequence (slice) of a sequence.
|
| RangeVector | |
| RangeVector.Iterator | |
| Rect |
\brief Template class for 2D rectangles
described by the following parameters:
- Coordinates of the top-left corner.
|
| Rect2d | |
| Rect2dVector | |
| Rect2dVector.Iterator | |
| Rect2f | |
| RectVector | |
| RectVector.Iterator | |
| RectVectorVector | |
| RectVectorVector.Iterator | |
| RNG |
\brief Random Number Generator
Random number generator.
|
| RNG_MT19937 |
\brief Mersenne Twister random number generator
Inspired by http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c
\todo document
|
| RotatedRect |
\brief The class represents rotated (i.e. not up-right) rectangles on a plane.
|
| Scalar |
\brief Template class for a 4-element vector derived from Vec.
|
| Scalar4f | |
| Scalar4i | |
| ScalarVector | |
| ScalarVector.Iterator | |
| Size |
\brief Template class for specifying the size of an image or rectangle.
|
| Size2d | |
| Size2f | |
| SizeVector | |
| SizeVector.Iterator | |
| SparseMat |
\brief The class SparseMat represents multi-dimensional sparse numerical arrays.
|
| SparseMat.Hdr |
the sparse matrix header
|
| SparseMat.Node |
sparse matrix node - element of a hash table
|
| SparseMatConstIterator |
\brief Read-Only Sparse Matrix Iterator.
|
| SparseMatIterator |
\brief Read-write Sparse Matrix Iterator
The class is similar to cv::SparseMatConstIterator,
but can be used for in-place modification of the matrix elements.
|
| Stream |
\brief This class encapsulates a queue of asynchronous calls.
|
| Stream.Impl | |
| Stream.StreamCallback | |
| StringVector | |
| StringVector.Iterator | |
| SVD |
\brief Singular Value Decomposition
Class for computing Singular Value Decomposition of a floating-point
matrix.
|
| TargetArchs |
\brief Class providing a set of static methods to check what NVIDIA\* card architecture the CUDA module was
built for.
|
| TermCriteria |
\brief The class defining termination criteria for iterative algorithms.
|
| Texture2D | |
| TickMeter |
\brief a Class to measure passing time.
|
| Timer | |
| TLSDataContainer |
TLS container base implementation
Don't use directly.
|
| TlsStorage |
\addtogroup core_utils
\{
|
| UMat |
\todo document
|
| UMatBytePairVector | |
| UMatData | |
| UMatVector | |
| UMatVector.Iterator | |
| WriteStructContext |
\cond IGNORED
|
Copyright © 2026. All rights reserved.