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
Re-exports§
pub use ptr_extern::PtrExtern;pub use ptr_extern::PtrExternCtor;pub use vector_extern::VectorExtern;pub use vector_extern::VectorExternCopyNonBool;
Modules§
Structs§
- This is a base class for all more or less complex algorithms in OpenCV
- Wrapper for OpenGL Client-Side Vertex arrays.
- Returns result of asynchronous operations
- Provides result of asynchronous operations
- Smart pointer for OpenGL buffer object with reference counting.
- BufferPool for use with CUDA streams
- Designed for command line parsing
- This class is used to perform the non-linear non-constrained minimization of a function with known gradient,
- Class for matching keypoint descriptors
- Class providing functionality for querying the specified GPU properties.
- This class is used to perform the non-linear non-constrained minimization of a function,
- ! Class passed to an error.
- File Storage Node class.
- used to iterate through sequences and mappings.
- XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or reading data to/from a file.
- @todo document
- @todo document
- Base storage class for GPU memory with reference counting.
- Class with reference counting wrapping special memory type allocation functions from CUDA.
- Data structure for salient point detectors.
- Linear Discriminant Analysis @todo document this class
- n-dimensional dense array class \anchor CVMat_Details
- /////////////////////////////// MatConstIterator //////////////////////////////////
- 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 )):
- ////////////////////////////// Matrix Expressions /////////////////////////////////
- @cond IGNORED
- Basic interface for all solvers
- Represents function being optimized
- struct returned by cv::moments
- Principal Component Analysis
- Base class for parallel data processors
- @deprecated
- This is similar to Rust
Arc, but handled by the C++. Some OpenCV functions insist on acceptingPtrinstead of a heap allocated object, so we need to satisfy those. - Random Number Generator
- Mersenne Twister random number generator
- Template class specifying a continuous subsequence (slice) of a sequence.
- The class represents rotated (i.e. not up-right) rectangles on a plane.
- Singular Value Decomposition
- The class SparseMat represents multi-dimensional sparse numerical arrays.
- Read-Only Sparse Matrix Iterator.
- Read-write Sparse Matrix Iterator
- the sparse matrix header
- sparse matrix node - element of a hash table
- This class encapsulates a queue of asynchronous calls.
- Class providing a set of static methods to check what NVIDIA* card architecture the CUDA module was built for.
- The class defining termination criteria for iterative algorithms.
- Smart pointer for OpenGL 2D texture memory with reference counting.
- a Class to measure passing time.
- @todo document
- Wrapper for C++ std::vector
- This is the proxy class for passing read-only input arrays into OpenCV functions.
- This type is very similar to InputArray except that it is used for input/output and output function parameters.
Enums§
- ! Flags that allow to midify some functions behavior. Used as set of flags.
- Various border types, image boundaries are denoted with
| - The target defines how you intend to use the buffer object.
- comparison types
- error codes
- Covariation flags
- Available CPU features.
- matrix decomposition types
- Enumeration providing CUDA computing features.
- file storage mode
- generalized matrix multiplication flags
- k-means flags
- Supported logging levels and their semantic
- Intermediate result type that’s produced by the Mat operations. Call MatExprResult::into_result to get the regular Result.
- norm types
- render mode
- return codes for cv::solveLP() function
- Criteria type, can be one of: COUNT, EPS or COUNT + EPS
- An Image Format describes the way that the images in Textures store their data.
- Usage flags for allocator
Constants§
- Use generic portable implementation
- Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform
- Default algorithm behaviour defined during OpenCV build
iiiiii|abcdefgh|iiiiiiiwith some specifiedi- same as BORDER_REFLECT_101
- Interpolation restricted within the ROI boundaries.
fedcba|abcdefgh|hgfedcb- same as BORDER_REFLECT_101
gfedcb|abcdefgh|gfedcbaaaaaaa|abcdefgh|hhhhhhhuvwxyz|abcdefgh|ijklmno- Treats outliers as transparent.cdefgh|abcdefgh|abcdefg- incorrect input align
- input COI is not supported
- input image depth is not supported by the function
- image size is invalid
- bad number of channels, for example, some functions accept only single channel matrices.
- offset is invalid
- number of dimensions is out of range
- incorrect input origin
- incorrect input roi
- image step is wrong, this may happen for a non-continuous matrix.
- The buffer will be used as a source for vertex data
- The buffer will be used for indices (in glDrawElements, for example)
- The buffer will be used for reading from OpenGL textures
- The buffer will be used for writing to OpenGL textures
- src1 is equal to src2.
- src1 is greater than or equal to src2.
- src1 is greater than src2.
- src1 is less than or equal to src2.
- src1 is less than src2.
- src1 is unequal to src2.
- 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.
- 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.
- 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.
- 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 ).
- 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.
- 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.
- Cascade Lake with AVX-512F/CD/BW/DQ/VL/VNNI
- Cannon Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI
- Common instructions AVX-512F/CD for all CPUs that support AVX-512
- Ice Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI/VNNI/VBMI2/BITALG/VPOPCNTDQ
- Knights Landing with AVX-512F/CD/ER/PF
- Knights Mill with AVX-512F/CD/ER/PF/4FMAPS/4VNNIW/VPOPCNTDQ
- Skylake-X with AVX-512F/CD/BW/DQ/VL
- performs an inverse 1D or 2D transform instead of the default forward transform.
- 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.
- Cholesky inline formula factorization; the matrix src1 must be symmetrical and positively defined
- eigenvalue decomposition; the matrix src1 must be symmetrical
- Gaussian elimination with the optimal pivot element chosen.
- 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
- QR factorization; the system can be over-defined and/or the matrix src1 can be singular
- singular value decomposition (SVD) method; the system can be over-defined and/or the matrix src1 can be singular
- 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.
- 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.
- performs an inverse 1D or 2D transform instead of the default forward transform.
- 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).
- 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.
- scales the result: divide it by the number of array elements. Normally, it is combined with DFT_INVERSE.
- < default compute mode (Multiple threads can use cudaSetDevice with this device)
- < compute-exclusive-thread mode (Only one thread in one process will be able to use cudaSetDevice with this device)
- < compute-exclusive-process mode (Many threads in one process will be able to use cudaSetDevice with this device)
- < compute-prohibited mode (No threads can use cudaSetDevice with this device)
- < Event uses blocking synchronization
- < Default event flag
- < Event will not record timing data
- < Event is suitable for interprocess use. DisableTiming must be set
- empty structure (sequence or mapping)
- synonym or REAL
- compact representation of a sequence or mapping. Used only by YAML writer
- an integer
- mapping
- the node has a name (i.e. it is element of a mapping).
- empty node
- floating-point number
- sequence
- text string in UTF-8 encoding
- synonym for STR
- 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
- value, open the file for appending
- flag, write rawdata in Base64 by default. (consider using WRITE_BASE64)
- flag, auto format
- flag, JSON format
- mask for format flags
- flag, XML format
- flag, YAML format
- Indicates being inside a map (a set of key-value pairs).
- < flag, read data from source or write data to the internal buffer (which is returned by FileStorage::release)
- Expecting a key/name in the current position.
- value, open the file for reading
- Initial or uninitialized state.
- Expecting a value in the current position.
- value, open the file for writing
- flag, enable both WRITE and BASE64
- transposes src1
- transposes src2
- transposes src3
- GPU API call error
- no CUDA support
- image header is NULL
- Use kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].
- Select random initial centers in each attempt.
- 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.
- Debug message. Disabled in the “Release” build.
- Error message
- Fatal (critical) error (unrecoverable internal error)
- Info message
- for using in setLogVevel() call
- Verbose (trace) messages. Requires verbosity level. Disabled in the “Release” build.
- Warning message
- 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.
- 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.
- block formula
- block formula
- block formula
- block formula
- flag
- flag
- bit-mask which can be used to separate norm type from norm flags
- OpenCL API call error
- OpenCL initialization error
- OpenGL API call error
- no OpenGL support
- indicates that the input samples are stored as matrix columns
- indicates that the input samples are stored as matrix rows
- the output is the mean vector of all rows/columns of the matrix.
- the output is the maximum (column/row-wise) of all rows/columns of the matrix.
- the output is the minimum (column/row-wise) of all rows/columns of the matrix.
- the output is the sum of all rows/columns of the matrix.
- the output is the sum of all squared rows/columns of the matrix.
- Rotate 90 degrees clockwise
- Rotate 270 degrees clockwise
- Rotate 180 degrees clockwise
- problem is feasible, but solver lost solution due to floating-point arithmetic errors
- there are multiple maxima for target function - the arbitrary one is returned
- there is only one maximum for target function
- problem is unbounded (target function can achieve arbitrary high values)
- problem is unfeasible (there are no points that satisfy all the constraints imposed)
- each matrix row is sorted in the ascending order.
- each matrix row is sorted in the descending order; this flag and the previous one are also mutually exclusive.
- each matrix column is sorted independently; this flag and the previous one are mutually exclusive.
- each matrix row is sorted independently
- 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.
- allow the algorithm to modify the decomposed matrix; it can save space and speed up processing. currently ignored.
- indicates that only a vector of singular values
wis to be processed, while u and vt will be set to empty matrices - assertion failed
- tracing
- pseudo error for back trace
- function arg/param is bad
- flag is wrong or not supported
- unsupported function
- bad format of mask (neither 8uC1 nor 8sC1)
- an allocated block has been corrupted
- bad CvPoint
- the input/output structure size is incorrect
- division by zero
- unknown /unspecified error
- incorrect filter offset value
- incorrect filter structure content
- in-place operation is not supported
- internal error (bad state)
- incorrect transform kernel content
- iteration didn’t converge
- insufficient memory
- the requested function/feature is not implemented
- null pointer
- request can’t be completed
- everything is ok
- some of parameters are out of range
- invalid syntax/structure of the parsed file
- formats of input/output arrays differ
- sizes of input/output structures do not match
- the data format/type is not supported by the function
- incorrect vector length
- the maximum number of iterations or elements to compute
- the desired accuracy or change in parameters at which the iterative algorithm stops
- ditto
- Depth
- Red, Green, Blue
- Red, Green, Blue, Alpha
Traits§
- Mutable methods for core::Algorithm
- Constant methods for core::Algorithm
- Mutable methods for core::Arrays
- Constant methods for core::Arrays
- Mutable methods for core::AsyncArray
- Constant methods for core::AsyncArray
- Mutable methods for core::AsyncPromise
- Constant methods for core::AsyncPromise
- Mutable methods for core::BufferPool
- Constant methods for core::BufferPool
- Mutable methods for core::Buffer
- Constant methods for core::Buffer
- Mutable methods for core::CommandLineParser
- Constant methods for core::CommandLineParser
- Mutable methods for core::ConjGradSolver
- Constant methods for core::ConjGradSolver
- Mutable methods for core::Context
- Constant methods for core::Context
- Mutable methods for core::Context_UserContext
- Constant methods for core::Context_UserContext
- Implement this trait types that are valid to use as Mat elements.
- Mutable methods for core::Detail_CheckContext
- Constant methods for core::Detail_CheckContext
- Mutable methods for core::DeviceInfo
- Constant methods for core::DeviceInfo
- Mutable methods for core::Device
- Constant methods for core::Device
- Mutable methods for core::DownhillSolver
- Constant methods for core::DownhillSolver
- Elementwise multiplication
- Mutable methods for core::Event
- Constant methods for core::Event
- Mutable methods for core::Exception
- Constant methods for core::Exception
- Mutable methods for core::FileNodeIterator
- Constant methods for core::FileNodeIterator
- Mutable methods for core::FileNode
- Constant methods for core::FileNode
- Mutable methods for core::FileStorage
- Constant methods for core::FileStorage
- Mutable methods for core::Formatted
- Constant methods for core::Formatted
- Mutable methods for core::Formatter
- Constant methods for core::Formatter
- Mutable methods for core::FunctionParams
- Constant methods for core::FunctionParams
- Mutable methods for core::GpuData
- Constant methods for core::GpuData
- Mutable methods for core::GpuMatND
- Constant methods for core::GpuMatND
- Mutable methods for core::GpuMat
- Constant methods for core::GpuMat
- Mutable methods for core::GpuMat_Allocator
- Constant methods for core::GpuMat_Allocator
- Mutable methods for core::Hamming
- Constant methods for core::Hamming
- Mutable methods for core::HostMem
- Constant methods for core::HostMem
- Mutable methods for core::Image2D
- Constant methods for core::Image2D
- Mutable methods for core::KernelArg
- Constant methods for core::KernelArg
- Mutable methods for core::Kernel
- Constant methods for core::Kernel
- Mutable methods for core::KeyPoint
- Constant methods for core::KeyPoint
- Mutable methods for core::LDA
- Constant methods for core::LDA
- Mutable methods for core::LogTag
- Constant methods for core::LogTag
- Mutable methods for core::MatConstIterator
- Constant methods for core::MatConstIterator
- Mutable methods for core::MatExpr
- Constant methods for core::MatExpr
- Mutable methods for core::MatOp
- Constant methods for core::MatOp
- Mutable methods for core::MatSize
- Constant methods for core::MatSize
- Mutable methods for core::MatStep
- Constant methods for core::MatStep
- Mutable methods for core::Mat
- Constant methods for core::Mat
- Mutable methods for core::Matx_AddOp
- Constant methods for core::Matx_AddOp
- Mutable methods for core::Matx_DivOp
- Constant methods for core::Matx_DivOp
- Mutable methods for core::Matx_MatMulOp
- Constant methods for core::Matx_MatMulOp
- Mutable methods for core::Matx_MulOp
- Constant methods for core::Matx_MulOp
- Mutable methods for core::Matx_ScaleOp
- Constant methods for core::Matx_ScaleOp
- Mutable methods for core::Matx_SubOp
- Constant methods for core::Matx_SubOp
- Mutable methods for core::Matx_TOp
- Constant methods for core::Matx_TOp
- Mutable methods for core::MinProblemSolver
- Constant methods for core::MinProblemSolver
- Mutable methods for core::MinProblemSolver_Function
- Constant methods for core::MinProblemSolver_Function
- Mutable methods for core::NodeData
- Constant methods for core::NodeData
- Mutable methods for core::OpenCLExecutionContext
- Constant methods for core::OpenCLExecutionContext
- Mutable methods for core::OriginalClassName
- Constant methods for core::OriginalClassName
- Mutable methods for core::PCA
- Constant methods for core::PCA
- Mutable methods for core::ParallelLoopBody
- Constant methods for core::ParallelLoopBody
- Mutable methods for core::PlatformInfo
- Constant methods for core::PlatformInfo
- Mutable methods for core::Platform
- Constant methods for core::Platform
- Mutable methods for core::ProgramSource
- Constant methods for core::ProgramSource
- Mutable methods for core::Program
- Constant methods for core::Program
- Mutable methods for core::Queue
- Constant methods for core::Queue
- Mutable methods for core::RNG
- Constant methods for core::RNG
- Mutable methods for core::RNG_MT19937
- Constant methods for core::RNG_MT19937
- Mutable methods for core::Range
- Constant methods for core::Range
- Mutable methods for core::SVD
- Constant methods for core::SVD
- Mutable methods for core::SparseMatConstIterator
- Constant methods for core::SparseMatConstIterator
- Mutable methods for core::SparseMatIterator
- Constant methods for core::SparseMatIterator
- Mutable methods for core::SparseMat
- Constant methods for core::SparseMat
- Mutable methods for core::SparseMat_Hdr
- Constant methods for core::SparseMat_Hdr
- Mutable methods for core::SparseMat_Node
- Constant methods for core::SparseMat_Node
- Mutable methods for core::Stream
- Constant methods for core::Stream
- Mutable methods for core::TargetArchs
- Constant methods for core::TargetArchs
- Mutable methods for core::Texture2D
- Constant methods for core::Texture2D
- Mutable methods for core::TickMeter
- Constant methods for core::TickMeter
- Mutable methods for core::Timer
- Constant methods for core::Timer
- Trait to serve as a replacement for
InputArrayin C++ OpenCV - Trait to serve as a replacement for
InputOutputArrayin C++ OpenCV - Trait to serve as a replacement for
OutputArrayin C++ OpenCV - Mutable methods for core::UMatData
- Constant methods for core::UMatData
- Mutable methods for core::UMat
- Constant methods for core::UMat
- Mutable methods for core::WriteStructContext
- Constant methods for core::WriteStructContext
- Mutable methods for core::_InputArray
- Constant methods for core::_InputArray
- Mutable methods for core::_InputOutputArray
- Constant methods for core::_InputOutputArray
- Mutable methods for core::_OutputArray
- Constant methods for core::_OutputArray
Functions§
- Calculates an absolute value of each matrix element.
- Calculates an absolute value of each matrix element.
- Calculates the per-element absolute difference between two arrays or between an array and a scalar.
- Calculates the per-element sum of two arrays or an array and a scalar.
- Calculates the per-element sum of two arrays or an array and a scalar.
- @relates cv::MatExpr
- Override search data path by adding new search location
- Append samples search data sub directory
- Calculates the weighted sum of two arrays.
- Calculates the weighted sum of two arrays.
- Attaches OpenCL context to OpenCV
- naive nearest neighbor finder
- naive nearest neighbor finder
- 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.
- 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.
- Inverts every bit of an array.
- Inverts every bit of an array.
- Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
- Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
- Calculates the per-element bit-wise “exclusive or” operation on two arrays or an array and a scalar.
- Calculates the per-element bit-wise “exclusive or” operation on two arrays or an array and a scalar.
- Computes the source location of an extrapolated pixel.
- Broadcast the given Mat to the given shape.
- Calculates the covariance matrix of a set of vectors.
- @overload
- Calculates the magnitude and angle of 2D vectors.
- Calculates the magnitude and angle of 2D vectors.
- Returns true if the specified feature is supported by the host hardware.
- C++ default parameters
- Note
- Checks every element of an input array for invalid values.
- Checks every element of an input array for invalid values.
- proxy for hal::Cholesky
- proxy for hal::Cholesky
- Performs the per-element comparison of two arrays or an array and scalar value.
- Copies the lower or the upper half of a square matrix to its another half.
- Copies the lower or the upper half of a square matrix to its another half.
- convert_
fp16 Deprecated Converts an array to half precision floating number. - Convert OpenCL buffer to UMat
- Parameters
- Parameters
- Parameters
- Parameters
- Converts Texture2D object to OutputArray.
- Convert OpenCL image2d_t to UMat
- Converts VASurfaceID object to OutputArray.
- Scales, calculates absolute values, and converts the result to 8-bit.
- Scales, calculates absolute values, and converts the result to 8-bit.
- Parameters
- Parameters
- Parameters
- Parameters
- Converts InputArray to Texture2D object.
- Converts InputArray to VASurfaceID object.
- Forms a border around an image.
- Forms a border around an image.
- C++ default parameters
- Note
- 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.
- Counts non-zero array elements.
- Creates a continuous matrix.
- Bindings overload to create a GpuMat from existing GPU memory.
- Bindings overload to create a GpuMat from existing GPU memory.
- @overload
- Bindings overload to create a GpuMat from existing GPU memory.
- Computes the cube root of an argument.
- Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
- Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
- Returns string of cv::Mat depth value: CV_8U -> “CV_8U” or “
” - Returns the determinant of a square floating-point matrix.
- checks whether current device supports the given feature
- Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
- Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
- Performs per-element division of two arrays or a scalar by an array.
- Performs per-element division of two arrays or a scalar by an array.
- Performs per-element division of two arrays or a scalar by an array.
- @overload
- C++ default parameters
- Note
- Calculates eigenvalues and eigenvectors of a symmetric matrix.
- Calculates eigenvalues and eigenvectors of a symmetric matrix.
- Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
- Ensures that the size of a matrix is big enough and the matrix has a proper type.
- ! Signals an error and raises the exception.
- error_1
Deprecated ! Signals an error and raises the exception. - Calculates the exponent of every array element.
- Extracts a single channel from src (coi is 0-based index)
- Calculates the angle of a 2D vector in degrees.
- Try to find requested data file
- Try to find requested data file
- C++ default parameters
- Note
- Returns the list of locations of non-zero pixels
- Flips a 2D array around vertical, horizontal, or both axes.
- Flips a n-dimensional at given axis
- Performs generalized matrix multiplication.
- Performs generalized matrix multiplication.
- Returns full configuration time cmake output.
- Returns list of CPU features enabled during compilation.
- Returns the number of CPU ticks.
- Returns the number of installed CUDA-enabled devices.
- ! Returns AlgorithmHint defined during OpenCV compilation. Defines ALGO_HINT_DEFAULT behavior.
- Returns the current device index set by cuda::setDevice or initialized by default.
- Get global log tag
- Returns feature name by ID
- Get global logging level
- Returns the number of threads used by OpenCV for parallel regions.
- Returns the number of logical CPUs available for the process.
- Returns the optimal DFT size for a given vector size.
- 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. - Returns the number of ticks.
- Returns the number of ticks per second.
- Get OpenCV type from DirectX type
- Get OpenCV type from DirectX type
- Returns major library version
- Returns minor library version
- Returns revision field of the library version
- Returns library version string
- Searches for files matching the specified pattern in a directory.
- Searches for files matching the specified pattern in a directory.
- Checks for the presence of at least one non-zero array element.
- Check if use of OpenVX is possible
- Applies horizontal concatenation to given matrices.
- Applies horizontal concatenation to given matrices.
- Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
- Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
- Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
- Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
- Checks if array elements lie between the elements of two other arrays.
- Parameters
- Parameters
- Parameters
- Parameters
- Creates OpenCL context from GL.
- Creates OpenCL context from VA.
- Creates OpenCL context from VA.
- Inserts a single channel to dst (coi is 0-based index)
- Finds the inverse or pseudo-inverse of a matrix.
- Finds the inverse or pseudo-inverse of a matrix.
- C++ default parameters
- Note
- Finds centers of clusters and groups input samples around the clusters.
- Finds centers of clusters and groups input samples around the clusters.
- Calculates the natural logarithm of every array element.
- proxy for hal::LU
- proxy for hal::LU
- Performs a look-up table transform of an array.
- Calculates the magnitude of 2D vectors.
- Calculates the Mahalanobis distance between two vectors.
- Maps Buffer object to process on CL side (convert to UMat).
- Maps Buffer object to process on CL side (convert to UMat).
- Calculates per-element maximum of two arrays or an array and a scalar.
- Calculates per-element maximum of two arrays or an array and a scalar.
- Calculates per-element maximum of two arrays or an array and a scalar.
- Calculates an average (mean) of array elements.
- Calculates an average (mean) of array elements.
- Calculates a mean and standard deviation of array elements.
- Calculates a mean and standard deviation of array elements.
- Creates one multi-channel array out of several single-channel ones.
- Calculates per-element minimum of two arrays or an array and a scalar.
- Calculates per-element minimum of two arrays or an array and a scalar.
- Finds the global minimum and maximum in an array
- Finds the global minimum and maximum in an array
- Finds the global minimum and maximum in an array.
- Finds the global minimum and maximum in an array.
- Finds the global minimum and maximum in an array.
- @overload
- Calculates per-element minimum of two arrays or an array and a scalar.
- Copies specified channels from input arrays to the specified channels of output arrays.
- Copies specified channels from input arrays to the specified channels of output arrays.
- Performs the per-element multiplication of two Fourier spectrums.
- Performs the per-element multiplication of two Fourier spectrums.
- Calculates the product of a matrix and its transposition.
- Calculates the product of a matrix and its transposition.
- Calculates the per-element scaled product of two arrays.
- Calculates the per-element scaled product of two arrays.
- Returns an empty InputArray or OutputArray.
- Calculates the absolute norm of an array.
- Calculates an absolute difference norm or a relative difference norm.
- Calculates an absolute difference norm or a relative difference norm.
- Calculates the absolute norm of an array.
- Calculates an absolute difference norm or a relative difference norm.
- Normalizes the norm or value range of an array.
- Normalizes the norm or value range of an array.
- Normalizes the norm or value range of an array.
- Parallel data processor
- Parallel data processor
- Replaces NaNs by given number
- Replaces NaNs by given number
- wrap PCA::backProject
- wrap PCA::operator()
- wrap PCA::operator() and add eigenvalues output parameter
- wrap PCA::operator() and add eigenvalues output parameter
- wrap PCA::operator() and add eigenvalues output parameter
- wrap PCA::operator()
- wrap PCA::operator()
- wrap PCA::project
- Performs the perspective matrix transformation of vectors.
- Calculates the rotation angle of 2D vectors.
- Calculates the rotation angle of 2D vectors.
- Calculates x and y coordinates of 2D vectors from their magnitude and angle.
- Calculates x and y coordinates of 2D vectors from their magnitude and angle.
- Raises every array element to a power.
- C++ default parameters
- Note
- C++ default parameters
- Note
- Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
- Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
- Shuffles the array elements randomly.
- Shuffles the array elements randomly.
- Fills the array with normally distributed random numbers.
- Generates a single uniformly-distributed random number or an array of random numbers.
- C++ default parameters
- Note
- C++ default parameters
- Note
- Finds out if there is any intersection between two rectangles
- Reduces a matrix to a vector.
- Finds indices of max elements along provided axis
- Finds indices of max elements along provided axis
- Finds indices of min elements along provided axis
- Finds indices of min elements along provided axis
- Reduces a matrix to a vector.
- Page-locks the memory of matrix and maps it for the device(s).
- Render OpenGL texture or primitives.
- Render OpenGL texture or primitives.
- Render OpenGL texture or primitives.
- @overload
- @overload
- Render OpenGL texture or primitives.
- Fills the output array with repeated copies of the input array.
- Fills the output array with repeated copies of the input array.
- Explicitly destroys and cleans up all resources associated with the current device in the current process.
- Rotates a 2D array in multiples of 90 degrees. The function cv::rotate rotates the array in one of three different ways:
- Calculates the sum of a scaled array and another array.
- Sets/resets the break-on-error mode.
- BufferPool management (must be called before Stream creation)
- Sets a device and initializes it for the current thread.
- Sets a CUDA device and initializes it for the current thread with OpenGL interoperability.
- Sets a CUDA device and initializes it for the current thread with OpenGL interoperability.
- Initializes a scaled identity matrix.
- Initializes a scaled identity matrix.
- C++ default parameters
- Note
- Set global logging level
- @cond IGNORED
- OpenCV will try to set the number of threads for subsequent parallel regions.
- Sets state of default random number generator.
- Enable/disable use of OpenVX
- Enables or disables the optimized code.
- Solves one or more linear systems or least-squares problems.
- Finds the real roots of a cubic equation.
- Solves one or more linear systems or least-squares problems.
- Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
- Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
- Finds the real or complex roots of a polynomial equation.
- Finds the real or complex roots of a polynomial equation.
- Sorts each row or each column of a matrix.
- Sorts each row or each column of a matrix.
- Divides a multi-channel array into several single-channel arrays.
- Divides a multi-channel array into several single-channel arrays.
- Calculates a square root of array elements.
- Calculates the per-element difference between two arrays or array and a scalar.
- Calculates the per-element difference between two arrays or array and a scalar.
- Calculates the sum of array elements.
- wrap SVD::backSubst
- wrap SVD::compute
- wrap SVD::compute
- Swaps two matrices
- Swaps two matrices
- Generates a unique temporary file name.
- Generates a unique temporary file name.
- ! Signals an error and terminate application.
- @cond IGNORED
- @cond IGNORED
- C++ default parameters
- Note
- Returns the default random number generator.
- Returns the trace of a matrix.
- Performs the matrix transformation of every array element.
- Transposes a matrix.
- Transpose for n-dimensional matrices.
- Returns string of cv::Mat depth value: CV_8UC3 -> “CV_8UC3” or “
” - Unmaps Buffer object (releases UMat, previously mapped from Buffer).
- Unmaps the memory of matrix and makes it pageable again.
- Check if use of OpenVX is enabled
- Returns the status of optimized code usage.
- Applies vertical concatenation to given matrices.
- Applies vertical concatenation to given matrices.
- Bindings overload to create a Stream object from the address stored in an existing CUDA Runtime API stream pointer (cudaStream_t).
- //////////////// XML & YAML I/O implementation //////////////////
- Write log message
- Write log message
Type Aliases§
- Shorter aliases for the most popular specializations of Vec<T,n>