API browser
The declarations your editor sees, made readable. Exact overloads, parameter descriptions, return types, ownership, and links to the pinned OpenCV 5 source.
Functions take explicit output matrices. Read the Python migration guide for namespaces, overload suffixes and memory ownership. Browse modules and constants.
This is the proxy class for passing read-only input arrays into OpenCV functions.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
This type is very similar to InputArray except that it is used for input/output and output function
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates the per-element absolute difference between two arrays or between an array and a scalar.
Native enum entries for access flag. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
imgproc_misc
Adds the per-element product of two input images to the accumulator image.
Adds the square of a source image to the accumulator image.
Updates a running average.
Applies an adaptive threshold to an array.
adaptive threshold algorithm
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates the per-element sum of two arrays or an array and a scalar.
Calculates the weighted sum of two arrays.
Class for implementing the wrapper which makes detectors and extractors to be affine invariant,
Create an owned AffineFeature instance with the supplied configuration.
Wrapper class for the OpenCV Affine Transformation algorithm. :
example: samples/cpp/snippets/detect_blob.cpp
Flags that allow to modify some functions' behavior. Used as set of flags.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
The base class for algorithms that align images of the same scene with different exposures
This algorithm converts images to median threshold bitmaps (1 for pixels brighter than median
ALIKED feature detector and descriptor extractor.
Creates ALIKED from a model file path.
aliked params value in the OpenCV API.
Compute alpha matte of an object in an image
imgcodecs_flags
\
Creates an instance of annoy index class with given parameters
Metrics used to calculate the distance between two feature vectors.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/snippets/falsecolor.cpp
Applies a user colormap on a given image.
geometry_subdiv2d
Approximates a polygon with a convex hull with a specified accuracy and number of sides.
Calculates a contour perimeter or a curve length.
Draws an arrow segment pointing from the first point to the second one.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
The main functionality of ArucoDetector class is detection of markers in an image with detectMarkers() method.
Board of ArUco markers
ChArUco board is a planar chessboard where the markers are placed inside the white squares of a chessboard.
aruco charuco detector value in the OpenCV API.
aruco charuco parameters value in the OpenCV API.
Native enum entries for aruco corner refine method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
struct DetectorParameters is used by ArucoDetector
Dictionary is a set of unique ArUco markers of the same size
Transform list of bytes to matrix of bits
Transform matrix of bits to list of bytes with 4 marker rotations
Named return value and scalar output parameters from aruco_Dictionary_identify1. Matrix and vector output arguments are filled in place.
Named return value and scalar output parameters from aruco_Dictionary_identify. Matrix and vector output arguments are filled in place.
Draws a set of Charuco corners
Draw a set of detected ChArUco Diamond markers
Draw detected markers in image
Extend base dictionary by new nMarkers
Generate a canonical marker image
Returns one of the predefined dictionaries referenced by DICT_.
Planar board with grid arrangement of markers
Predefined markers dictionaries/sets
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
struct RefineParameters is used by ArucoDetector
Returns result of asynchronous operations
Base class for background/foreground segmentation. :
K-nearest neighbours - based Background/Foreground Segmentation Algorithm.
Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
barcode barcode detector value in the OpenCV API.
base cascade classifier value in the OpenCV API.
naive nearest neighbor finder
Brute-force descriptor matcher.
Brute-force matcher create method.
Background subtraction based on counting.
Background Subtractor module based on the algorithm given in [Gold2012] .
Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at [LGuo2016]
This is for calculation of the LSBP descriptors.
Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
Creates a CNT Background Subtractor
Creates a GMG Background Subtractor
Creates an instance of BackgroundSubtractorGSOC algorithm.
Creates an instance of BackgroundSubtractorLSBP algorithm.
Creates mixture-of-gaussian background subtractor
Creates an instance of SyntheticSequenceGenerator.
Native enum entries for bgsegm lsbpcamera motion compensation. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Synthetic frame sequence generator for testing background subtraction algorithms.
Applies the bilateral filter to an image.
class which allows the Gipsa/Listic Labs model to be used with OpenCV.
Constructors from standardized interfaces : retreive a smart pointer to a Retina instance
Constructors from standardized interfaces : retreive a smart pointer to a Retina instance
a wrapper class which allows the tone mapping algorithm of Meylan&al(2007) to be used with OpenCV.
Create an owned bioinspired_RetinaFastToneMapping instance with the supplied configuration.
class which provides a transient/moving areas segmentation module
bioinspired_TransientAreasSegmentationModule_create: allocator
computes bitwise conjunction of the two arrays (dst = src1 & src2)
Inverts every bit of an array.
Calculates the per-element bit-wise disjunction of two arrays or an
Calculates the per-element bit-wise "exclusive or" operation on two
Performs linear blending of two images:
Blurs an image using the normalized box filter.
Computes the source location of an extrapolated pixel.
Various border types, image boundaries are denoted with the `|` character in the table below, when describing each method.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates the up-right bounding rectangle of a point set or non-zero pixels of gray-scale image.
Blurs an image using the box filter.
Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.
Broadcast the given Mat to the given shape.
Builds a Minimum Spanning Tree (MST) using the specified algorithm (see `MSTAlgorithm`).
Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.
Calculates the back projection of a histogram.
Note: use #COVAR_ROWS or #COVAR_COLS flag
this variant supports only uniform histograms.
example: samples/python/snippets/opt_flow.py
example: samples/cpp/lkdemo.cpp
Finds the camera intrinsic and extrinsic parameters from several views of a calibration
Finds the camera intrinsic and extrinsic parameters from several views of a calibration
Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
The base class for camera response calibration algorithms.
Inverse camera response function is extracted for each brightness value by minimizing an objective
Estimates intrinsics and extrinsics (camera pose) for multi-camera system a.k.a multiview calibration.
Estimates intrinsics and extrinsics (camera pose) for multi-camera system a.k.a multiview calibration.
Inverse camera response function is extracted for each brightness value by minimizing an objective
Computes useful camera characteristics from the camera intrinsic matrix.
Named return value and scalar output parameters from calibrationMatrixValues. Matrix and vector output arguments are filled in place.
Maximal size of camera internal parameters (initrinsics) vector
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Finds an object center, size, and orientation.
imgproc_filter
Finds edges in an image using the Canny algorithm with custom image gradient.
Calculates the magnitude and angle of 2D vectors.
example: samples/facedetect.cpp
Convert a legacy Haar cascade file to the newer cascade serialization format in the virtual filesystem.
Enum of the possible types of ccm.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Macbeth and Vinyl ColorChecker with 2deg D50
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Core class of ccm model
Native enum entries for ccm color space. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Enum of possible functions to calculate the distance between colors.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Applies gamma correction to the input image.
Enum of the possible types of initial method.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Linearization transformation type
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Checks whether the image contains chessboard of the specific size or not.
Returns true if the specified feature is supported by the host hardware.
Checks every element of an input array for invalid values.
Named return value and scalar output parameters from checkRange. Matrix and vector output arguments are filled in place.
An Chi based cost extraction. :
example: samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_2.cpp
A detected circle described by its center coordinates and radius.
circles grid finder parameters value in the OpenCV API.
Native enum entries for circles grid finder parameters grid type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
imgproc_shape
An owned handle to an object in this OpenCV instance. Use `using` or `delete()` to release native resources.
Clips the line against the image rectangle.
Named return value and scalar output parameters from clipLine. Matrix and vector output arguments are filled in place.
comparison types
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Given an original color image, two differently colored versions of this image can be mixed
the color conversion codes
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
KinectFusion implementation
Create an owned colored_kinfu_ColoredKinFu instance with the supplied configuration.
colored kinfu params value in the OpenCV API.
Coarse parameters
ColoredTSDF parameters
Default parameters
HashTSDF parameters
imgproc_shape
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Performs the per-element comparison of two arrays or an array and scalar value.
Compares two histograms.
Copies the lower or the upper half of a square matrix to its another half.
Combines two rotation-and-shift transformations.
For points in an image of a stereo pair, computes the corresponding epilines in the other image.
Computes the Enhanced Correlation Coefficient (ECC) value between two images
example: samples/cpp/connected_components.cpp
connected components algorithm
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
imgproc_misc
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/connected_components.cpp
computes the connected components labeled image of boolean image and also produces a statistics output for each label
computes the connected components labeled image of boolean image and also produces a statistics output for each label
the contour approximation algorithm
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates a contour area.
Converts image transformation maps from one representation to another.
Converts points from homogeneous to Euclidean space.
Converts points from Euclidean to homogeneous space.
Scales, calculates absolute values, and converts the result to 8-bit.
example: samples/cpp/geometry.cpp
Finds the convexity defects of a contour.
example: samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp
This is an overloaded member function, provided for convenience (python)
example: samples/python/snippets/texture_flow.py
Harris corner detector.
Calculates the minimal eigenvalue of gradient matrices for corner detection.
Refines the corner locations.
photo_render
Refines coordinates of corresponding points.
Counts non-zero array elements.
core_utils
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Complete constructor
Creates AlignMTB object
Creates KNN Background Subtractor
Creates MOG2 Background Subtractor
Creates CalibrateDebevec object
Creates CalibrateRobertson object
Create an owned HistogramCostExtractor instance with the supplied configuration.
Creates a smart pointer to a cv::CLAHE class and initializes it.
Create an owned HistogramCostExtractor instance with the supplied configuration.
Create an owned HistogramCostExtractor instance with the supplied configuration.
Creates a smart pointer to a cv::GeneralizedHoughBallard class and initializes it.
Creates a smart pointer to a cv::GeneralizedHoughGuil class and initializes it.
TypeScript conveniences for the native CPU graph API and Python's graph factories.
This function computes a Hanning window coefficients in two dimensions.
createHausdorffDistanceExtractor: Constructor
Creates a smart pointer to a LineSegmentDetector object and initializes it.
Creates MergeDebevec object
Creates MergeMertens object
Creates MergeRobertson object
Create an owned HistogramCostExtractor instance with the supplied configuration.
Load an isolated CPU OpenCV WebAssembly instance in a browser, worker or Node.js.
Create an owned ShapeContextDistanceExtractor instance with the supplied configuration.
Create file and iterable source factories for one isolated OpenCV instance.
Complete constructor
Creates simple linear mapper with gamma correction
Creates TonemapDrago object
Creates TonemapMantiuk object
Creates TonemapReinhard object
Value factories use this instance's native algorithms for geometric operations.
Computes the cube root of an argument.
Native enum entries for cuda surf cuda keypoint layout. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Construct an OpenCV 5 matrix type code with a supported depth and 1 to 128 channels.
Extract the scalar element depth from a combined OpenCV matrix type code.
imgproc_misc
Converts an image from one color space to another where the source image is
Enum of data layout for model inference.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for datasets action type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for datasets background type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for datasets dataset type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for datasets gender type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for datasets illumination type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for datasets image type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for datasets pose type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for datasets sample type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
Decode encoded bytes with native codecs on the initialized shared engine, in browsers or Node.
photo_hdr
Decompose an essential matrix to possible rotations and translation.
example: samples/cpp/tutorial_code/features/Homography/decompose_homography.cpp
Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
matrix decomposition types
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
main function for all demosaicing processes
Primal-dual algorithm is an algorithm for solving special types of variational problems (that is,
example: samples/python/snippets/dis_opt_flow.py
Converts a depth image to 3d points. If the mask is empty then the resulting array has the same dimensions as `depth`,
depthTo3dSparse native operation from cv::depthTo3dSparse.
features_main
Creates a descriptor matcher of a given type with the default parameters (using default
Creates a descriptor matcher of a given type with the default parameters (using default
Native enum entries for descriptor matcher matcher type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Affine transformation based estimator.
Features matcher similar to cv::detail::BestOf2NearestMatcher which
FIXME: These traits and enum and possible numerous switch(kind)
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Features matcher which finds two best matches for each feature and leaves the best one only if the
Create an owned detail_BestOf2NearestMatcher instance with the supplied configuration.
detail best of2 nearest range matcher value in the OpenCV API.
Base class for all blenders.
Create an owned detail_Blender instance with the supplied configuration.
Exposure compensator which tries to remove exposure related artifacts by adjusting image block
Exposure compensator which tries to remove exposure related artifacts by adjusting image blocks.
Exposure compensator which tries to remove exposure related artifacts by adjusting image block
Bundle adjuster that expects affine transformation
Bundle adjuster that expects affine transformation with 4 DOF
Base class for all camera parameters refinement methods.
Implementation of the camera parameters refinement algorithm which minimizes sum of the distances
Implementation of the camera parameters refinement algorithm which minimizes sum of the reprojection
Estimates focal lengths for each given camera.
Describes camera parameters.
Exposure compensator which tries to remove exposure related artifacts by adjusting image
Detect keypoints and compute descriptors for the supplied panorama images, optionally using masks.
Detect keypoints and descriptors for one panorama image and return its native image-feature record.
Create an owned void instance with the supplied configuration.
Create an owned void instance with the supplied configuration.
Create an owned void instance with the supplied configuration.
Native enum entries for detail cv feature params feature type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
detail dp seam finder value in the OpenCV API.
Native enum entries for detail dp seam finder cost function. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Rotation estimator base class.
Base class for all exposure compensators.
Create an owned detail_ExposureCompensator instance with the supplied configuration.
Simple blender which mixes images at its borders.
Feature matchers base class.
Tries to estimate focal lengths from the given homography under the assumption that the camera
Named return value and scalar output parameters from detail_focalsFromHomography. Matrix and vector output arguments are filled in place.
Exposure compensator which tries to remove exposure related artifacts by adjusting image
Minimum graph cut-based seam estimator. See details in [Kwatra03] .
Base class for all minimum graph-cut-based seam estimators.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Homography based rotation estimator.
Structure containing image keypoints and descriptors.
Keep the largest connected image component under the match-confidence threshold and return its original image indices.
Features matcher that adapts LightGlueMatcher (DescriptorMatcher) to the
Auxiliary functions
Structure containing information about matches between two images.
Blender which uses multi-band blending algorithm (see [BA83]).
Stub bundle adjuster that does nothing.
Stub exposure compensator which does nothing.
Auxiliary functions
Stub seam estimator which does nothing.
This enum is utilized mostly by GArray and GOpaque to store and recognize their internal data
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Auxiliary functions
Base class for all pairwise seam estimators.
ATTENTION! This class is used internally in Large KinFu.
Base class for warping logic implementation.
Restores source image
Reconstruct an image from a Laplacian pyramid. This upstream name denotes an OpenCL-oriented helper; accelerated OpenCL execution is unavailable here.
Compute the bounding rectangle covering images placed at their supplied top-left offsets.
Compute the bounding rectangle from image offsets and sizes.
Compute the rectangle shared by all images placed at the supplied offsets.
Return the top-left coordinate of the combined image bounds.
Base class for a seam estimator.
Create an owned detail_SeamFinder instance with the supplied configuration.
Returns random 'count' element subset of the {0,1,...,size-1} set
Extracts rotation and translation matrices from matrix H representing
Named return value and scalar output parameters from detail_SphericalProjector_mapBackward. Matrix and vector output arguments are filled in place.
Named return value and scalar output parameters from detail_SphericalProjector_mapForward. Matrix and vector output arguments are filled in place.
Return the current native stitching diagnostic log level.
Returns string of cv::Mat depth value: CV_8UC3 -> "CV_8UC3" or cv::String()
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Base Timelapser class, takes a sequence of images, applies appropriate shift, stores result in dst_.
Create an owned detail_Timelapser instance with the supplied configuration.
detail timelapser crop value in the OpenCV API.
TrackerSampler based on CSC (current state centered), used by MIL algorithm TrackerMIL
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Voronoi diagram-based seam estimator.
Tries to make panorama more horizontal (or vertical).
Native enum entries for detail wave correct kind. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
This filter enhances the details of a particular image.
Returns the determinant of a square floating-point matrix.
example: samples/python/snippets/dft.py
Native enum entries for dft flags. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp
DISK feature detector and descriptor, based on a DNN model.
Creates a DISK detector.
Create an owned DISK instance with the supplied configuration.
DIS optical flow algorithm.
Creates an instance of DISOpticalFlow
imgproc_segmentation
distanceTransform algorithm flags
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
imgproc_transform
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
imgproc_segmentation
Distance types for Distance Transform and M-estimators
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
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 the per-element division of the first Fourier spectrum by the second Fourier spectrum.
DMatch /////////////////////////////////
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Activation type enumeration for dispatched activation function retrieval.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Indicate that an actual data is on CPU.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
GatherND layer
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Enum of computation backends supported by layers.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Creates 4-dimensional blob from image. Optionally resizes and crops `image` from center,
Creates 4-dimensional blob from series of images. Optionally resizes and
Creates 4-dimensional blob from series of images with given params.
Creates 4-dimensional blob from series of images with given params.
Creates 4-dimensional blob from image with given params.
Creates 4-dimensional blob from image with given params.
This class represents high-level API for classification models.
Named return value and scalar output parameters from dnn_ClassificationModel_classify. Matrix and vector output arguments are filled in place.
This class represents high-level API for object detection networks.
This struct stores the scalar value (or array) of one of the following type: double, cv::String or int64.
Native enum entries for dnn engine type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Return an owned vector of execution targets available for a DNN backend in this build. CPU OpenCV inference is enabled.
Returns Inference Engine internal backend API.
Returns Inference Engine CPU type.
Returns Inference Engine VPU type.
Processing params of image to blob.
Enum of image processing mode.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Parse a 4D blob and output the images it contains as 2D arrays through a simpler data structure
This class represents high-level API for keypoints models
This interface class allows to build new Layers - are building blocks of networks.
A DNN layer's instance name, type, learned blobs and named configuration values.
Shared reduction enum for DNN loss layers
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
This class is presented high-level API for neural networks.
Native enum entries for dnn model format. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Element wise operation on inputs
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
This class allows to create and manipulate comprehensive artificial neural networks.
Named return value and scalar output parameters from dnn_Net_getMemoryConsumption. Matrix and vector output arguments are filled in place.
Destructor frees the net only if there aren't references to the net anymore.
Read an Intel Model Optimizer model from buffers. Its required OpenVINO backend is not linked in this WASM build.
Performs non maximum suppression given boxes and corresponding scores.
Performs batched non maximum suppression on given boxes and corresponding scores across different classes.
Performs non maximum suppression given boxes and corresponding scores.
Native enum entries for dnn profiling mode. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Read deep learning network represented in one of the supported formats.
Read deep learning network represented in one of the supported formats.
Load a network from Intel's Model Optimizer intermediate representation.
Load a network from Intel's Model Optimizer intermediate representation.
Reads a network model <a href="https://onnx.ai/">ONNX</a>.
Reads a network model from <a href="https://onnx.ai/">ONNX</a>
Reads a network model stored in <a href="https://www.tensorflow.org/">TensorFlow</a> framework's format.
Reads a network model stored in <a href="https://www.tensorflow.org/">TensorFlow</a> framework's format.
Reads a network model stored in <a href="https://www.tensorflow.org/lite">TFLite</a> framework's format.
Reads a network model stored in <a href="https://www.tensorflow.org/lite">TFLite</a> framework's format.
Creates blob from .pb file.
GatherElements layer
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Register a synchronous TypeScript DNN layer factory. It receives borrowed model blobs and returns shape and forward callbacks. Forward callbacks write preallocated outputs; borrowe
Release a HDDL plugin.
Release a Myriad device (binded by OpenCV).
This class represents high-level API for segmentation models
Specify Inference Engine internal backend API.
Performs soft non maximum suppression given boxes and corresponding scores.
Enum of Soft NMS methods.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
A class to upscale images via convolutional neural networks.
Empty constructor for python
Enum of target devices for computations.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Base class for text detection networks
This class represents high-level API for text detection DL networks compatible with DB model.
This class represents high-level API for text detection DL networks compatible with EAST model.
This class represents high-level API for text recognition networks.
High-level tokenizer wrapper for DNN usage.
Load a tokenizer from a model directory.
Native enum entries for dnn tracing mode. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Unregister a TypeScript layer factory for future DNN layer creation. Existing networks retain their constructed layers.
Create a text representation for a binary network stored in protocol buffer format.
Creates a layer implementation. Clone borrowed matrices when keeping them beyond a callback.
Synchronous CPU callbacks. Write into the preallocated outputs; do not resize or retain borrowed handles.
Custom DNN layer initialization. Blob handles are borrowed until the factory returns.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
This is a C++ abstract class, it provides external user API to work with DPM.
dpm dpmdetector object detection value in the OpenCV API.
Renders the detected chessboard corners.
example: samples/python/snippets/contours.py
Draw axes of the world/object coordinate system from pose estimation. See: solvePnP
Draws keypoints.
-----------------------------------------------------------------------------------------
Draws the found matches of keypoints from two images.
Draws the found matches of keypoints from two images.
features_match
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Draws the found matches of keypoints from two images.
CPU drawing primitives accepted by the G-API renderer.
Backwards compatibility for old versions
Create an owned dynafu_DynaFu instance with the supplied configuration.
struct ECCParameters is used by findTransformECCMultiScale
Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing
Calculates eigenvalues and eigenvectors of a symmetric matrix.
Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
Draws a simple or thick elliptic arc or fills an ellipse sector.
Draws a simple or thick elliptic arc or fills an ellipse sector.
Approximates an elliptic arc with a polyline.
Text accepted by native string parameters. JavaScript strings are encoded as UTF-8; byte buffers supply the encoded bytes directly.
Computes the "minimal work" distance between two weighted point configurations.
An EMD based cost extraction. :
An EMD-L1 based cost extraction. :
Earth mover distance and the scalar lower bound returned alongside the supplied flow output.
Create an empty array descriptor for native graph metadata. Array element type is determined by the graph node.
Create an empty opaque-value descriptor for native graph metadata.
Create an empty scalar descriptor for native graph metadata.
Encode a shared-engine matrix to independent image bytes; no DOM is required.
Equalizes the histogram of a grayscale image.
imgproc_feature
Error_Code: error codes
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Computes an optimal affine transformation between two 2D point sets.
Computes an optimal affine transformation between two 2D point sets.
Computes an optimal affine transformation between two 3D point sets.
Computes an optimal affine transformation between two 3D point sets.
Named return value and scalar output parameters from estimateAffine3D1. Matrix and vector output arguments are filled in place.
Computes an optimal limited affine transformation with 4 degrees of freedom between
Estimates the sharpness of a detected chessboard.
Computes a pure 2D translation between two 2D point sets.
Computes an optimal translation between two 3D point sets.
Details of a native OpenCV exception, including its error code, message, function and source location.
Read an OpenCV cv::Exception from a numeric native exception pointer. Its message includes the failing native assertion or operation.
Calculates the exponent of every array element.
Extracts a single channel from src (coi is 0-based index)
base for two classes
Implementation of bio-inspired features (BIF) from the paper:
Create an owned face_BIF instance with the supplied configuration.
Facemark
construct a Kazemi facemark detector
construct an LBF facemark detector
Utility to draw the detected facial landmark points
face eigen face recognizer value in the OpenCV API.
Create an owned face_EigenFaceRecognizer instance with the supplied configuration.
Abstract base class for all facemark models
face facemark aam value in the OpenCV API.
face facemark kazemi value in the OpenCV API.
face facemark lbf value in the OpenCV API.
Abstract base class for trainable facemark models
Abstract base class for all face recognition models
Named return value and scalar output parameters from face_FaceRecognizer_predict. Matrix and vector output arguments are filled in place.
face fisher face recognizer value in the OpenCV API.
Create an owned face_FisherFaceRecognizer instance with the supplied configuration.
Default face detector
face lbphface recognizer value in the OpenCV API.
Create an owned face_LBPHFaceRecognizer instance with the supplied configuration.
A utility to load list of paths to training image and annotation file.
A utility to load facial landmark information from a given file.
A utility to load facial landmark dataset from a single file.
A utility to load facial landmark information from the dataset.
This function extracts the data for training from .txt files which contains the corresponding image name and landmarks.
Minimum Average Correlation Energy Filter
face_MACE_create: constructor
face_MACE_load: constructor
Abstract base class for all strategies of prediction result handling
Default predict collector
Static constructor
DNN-based face detector
Creates an instance of face detector class with given parameters
Creates an instance of face detector class with given parameters
DNN-based face recognizer
Creates an instance of this class with given parameters
Creates an instance of this class from a buffer containing the model weights and configuration.
Definition of distance used for calculating the distance between two face features
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Class computing a dense optical flow using the Gunnar Farneback's algorithm.
Create an owned FarnebackOpticalFlow instance with the supplied configuration.
Calculates the angle of a 2D vector in degrees.
Wrapping class for feature detection using the FAST method.
Create an owned FastFeatureDetector instance with the supplied configuration.
Native enum entries for fast feature detector detector type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
photo_inpaint
Perform image denoising using Non-local Means Denoising algorithm
Modification of fastNlMeansDenoising function for colored images
Modification of fastNlMeansDenoisingMulti function for colored images sequences
Modification of fastNlMeansDenoising function for images sequence where consecutive images have been
Modification of fastNlMeansDenoising function for images sequence where consecutive images have been
Base Classes
File Storage Node class.
File metadata in the instance's in-memory filesystem.
XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or
file storage mode
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for file storage state. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
-----------------------------------------------------------------------------------------
example: samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_1.cpp
Convolves an image with the kernel.
Convolves an image with the kernel.
filter2 dparams value in the OpenCV API.
Filters homography decompositions based on additional information.
Filters off small noise blobs (speckles) in the disparity map
finds subpixel-accurate positions of the chessboard corners
Finds the positions of internal corners of the chessboard.
Finds the positions of internal corners of the chessboard using a sector based approach.
Finds the positions of internal corners of the chessboard using a sector based approach.
Finds centers in the grid of circles.
Finds centers in the grid of circles.
Finds contours in a binary image.
Find contours using link runs algorithm
Find contours using link runs algorithm
Calculates an essential matrix from the corresponding points in two images.
Calculates an essential matrix from the corresponding points in two images.
Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
example: samples/cpp/snippets/epipolar_lines.cpp
example: samples/cpp/snippets/epipolar_lines.cpp
example: samples/cpp/snippets/epipolar_lines.cpp
example: samples/cpp/tutorial_code/features/Homography/pose_from_homography.cpp
example: samples/cpp/tutorial_code/features/Homography/pose_from_homography.cpp
Returns the list of locations of non-zero pixels
Find the planes in a depth image
example: samples/cpp/image_alignment.cpp
example: samples/cpp/image_alignment.cpp
Finds the geometric transform (warp) between two images in terms of the ECC criterion [EP08]. Uses pyramids.
Finds the geometric transform (warp) between two images in terms of the ECC criterion [EP08]
Generates a mask of finite float values, i.e. not NaNs nor Infs.
Performs camera calibration
Distorts 2D points using fisheye model.
Overload of distortPoints function to handle cases when undistorted points are got with non-identity
Estimates new camera intrinsic matrix for undistortion or rectification.
Computes undistortion and rectification maps for image transform by cv::remap(). If D is empty zero
Projects points using fisheye model
Finds an object pose from 3D-2D point correspondences for fisheye camera model.
Finds an object pose from 3D-2D point correspondences using the RANSAC scheme for fisheye camera moodel.
Performs stereo calibration
Performs stereo calibration
Stereo rectification for fisheye camera model
Transforms an image to compensate for fisheye lens distortion.
Undistorts 2D points using fisheye camera model
Fits an ellipse around a set of 2D points.
Fits an ellipse around a set of 2D points.
Fits an ellipse around a set of 2D points.
Fits a line to a 2D or 3D point set.
flann distance type value in the OpenCV API.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for flann flann index type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
A nearest-neighbor search index over feature vectors. Choose index and search parameters for the descriptor type and distance metric.
Named configuration values used when constructing a FLANN nearest-neighbor index.
Configuration for a randomized forest of kd-trees used to search floating-point descriptors.
Configuration for exhaustive nearest-neighbor search over all descriptor rows.
Configuration for a locality-sensitive hashing index over binary descriptors.
Search configuration controlling the number of examined leaves, approximation tolerance and result ordering.
Flann-based descriptor matcher.
Create an owned FlannBasedMatcher instance with the supplied configuration.
Flips a 2D array around vertical, horizontal, or both axes.
Flips a n-dimensional at given axis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Fills a connected component with the given color.
floodfill algorithm flags
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Wrapper on top of a truetype/opentype/etc font, i.e. Freetype's FT_Face.
Formatter_FormatType: todo: document
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Create FreeType2 Instance
freetype free type2 value in the OpenCV API.
Named return value and scalar output parameters from freetype_FreeType2_getTextSize. Matrix and vector output arguments are filled in place.
Creates kernel from general functions.
Creates kernel from basic functions.
Image filtering
Computes components of the array using direct `F^0`-transform.
Sligtly less accurate version of `F^0`-transfrom computation optimized for higher speed. The methods counts with linear basic function.
Sligtly less accurate version of `F^0`-transfrom computation optimized for higher speed. The methods counts with linear basic function.
Computes inverse `F^0`-transfrom.
Computes `F^0`-transfrom and inverse `F^0`-transfrom at once and return state.
Computes `F^0`-transfrom and inverse `F^0`-transfrom at once.
Computes components of the array using direct `F^1`-transform.
Creates horizontal matrix for `F^1`-transform computation.
Creates vertical matrix for `F^1`-transform computation.
Computes inverse `F^1`-transfrom.
Computes elements of `F^1`-transform components.
Computes `F^1`-transfrom and inverse `F^1`-transfrom at once.
Image inpainting
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Calculates the per-element absolute difference between two matrices.
Calculates absolute value of matrix elements.
namespace streaming
Calculates the per-element sum of matrix and given scalar.
Calculates the per-element sum of matrix and given scalar.
Calculates the weighted sum of two matrices.
Converts an image from BayerGR color space to RGB.
Converts an image from BGR color space to gray-scaled.
Converts an image from BGR color space to I420 color space.
Converts an image from BGR color space to LUV color space.
gapi_shape
Converts an image from BGR color space to YUV color space.
Applies the bilateral filter to an image.
computes bitwise conjunction of the two matrixes (src1 & src2)
computes bitwise conjunction of the two matrixes (src1 & src2)
Inverts every bit of an array.
computes bitwise disjunction of the two matrixes (src1 | src2)
computes bitwise disjunction of the two matrixes (src1 | src2)
computes bitwise logical "exclusive or" of the two matrixes (src1 ^ src2)
computes bitwise logical "exclusive or" of the two matrixes (src1 ^ src2)
Blurs an image using the normalized box filter.
Calculates the up-right bounding rectangle of a point set or non-zero pixels
Calculates the up-right bounding rectangle of a point set or non-zero pixels
Calculates the up-right bounding rectangle of a point set or non-zero pixels
Blurs an image using the box filter.
gapi_filters
Calculates the magnitude and angle of 2D vectors.
Performs the per-element comparison of two matrices checking if elements from first matrix are equal to elements in second.
Performs the per-element comparison of two matrices checking if elements from first matrix are equal to elements in second.
Performs the per-element comparison of two matrices checking if elements from first matrix are greater or equal compare to elements in second.
Performs the per-element comparison of two matrices checking if elements from first matrix are greater or equal compare to elements in second.
gapi_math
gapi_math
Performs the per-element comparison of two matrices checking if elements from first matrix are less or equal compare to elements in second.
Performs the per-element comparison of two matrices checking if elements from first matrix are less or equal compare to elements in second.
Performs the per-element comparison of two matrices checking if elements from first matrix are less than elements in second.
Performs the per-element comparison of two matrices checking if elements from first matrix are less than elements in second.
Performs the per-element comparison of two matrices checking if elements from first matrix are not equal to elements in second.
Performs the per-element comparison of two matrices checking if elements from first matrix are not equal to elements in second.
Declares a new G-API Operation. See [Kernel API](`gapi_kernel_api`) for more details.
Applies horizontal concatenation to given matrices.
The function horizontally concatenates given number of GMat matrices (with the same number of columns).
Applies vertical concatenation to given matrices.
The function vertically concatenates given number of GMat matrices (with the same number of columns).
Converts a matrix to another data depth with optional scaling.
namespace streaming
Create an owned package of native core graph kernels for the CPU backend.
Create an owned package of native core graph kernels for the line-buffered Fluid CPU backend.
Create an owned package of native core graph kernels for the OpenCL backend. OpenCL acceleration is unavailable in this build.
Counts non-zero array elements.
Crops a 2D matrix.
Dilates an image by using a specific structuring element.
Dilates an image by using 3 by 3 rectangular structuring element.
FIXME: merge with mulc
Divides matrix by scalar.
Divides scalar by matrix.
Configuration for a named OpenCV DNN graph network. Retains the supplied Net and selects its CPU backend. Configure image preprocessing before packaging with `cv.gapi.networks`.
Create an empty native kernel package that can be combined with CPU implementations.
Equalizes the histogram of a grayscale image.
Erodes an image by using a specific structuring element.
Erodes an image by using 3 by 3 rectangular structuring element.
Convolves an image with the kernel.
Flips a 2D matrix around vertical, horizontal, or both axes.
GAPI_EXPORTS_W void blur( InputArray src, OutputArray dst,
\addtogroup gapi_compile_args
Note: the below code _is_ part of STANDALONE build,
Determines strong corners on an image.
Converts an image from I420 color space to BGR color space.
Converts an image from I420 color space to BGR color space.
Native enum entries for gapi ie detail param desc kind. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for gapi ie infer mode. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Create network parameter configuration. These parameter objects describe an optional OpenVINO or ONNX Runtime backend, which is not linked in this WASM build. Use gapi.dnn.Params f
Create network parameter configuration. These parameter objects describe an optional OpenVINO or ONNX Runtime backend, which is not linked in this WASM build. Use gapi.dnn.Params f
NB: Used by python wrapper
Specifies how G-API and IE should trait input data
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Create an owned package of native image-processing graph kernels for the line-buffered Fluid CPU backend.
Construct native graph inference for named tensor/image inputs, one region, or a list of regions. Compile with a matching OpenCV DNN network tag. Region inference requires a single
Construct inference over equally sized named lists of rectangles and/or prepared tensors. Rectangles are cropped from the shared image; tensor lists bypass preprocessing. Empty inp
Applies a range-level threshold to each matrix element.
Calculates the integral of an image.
Finds centers of clusters and groups input samples around the clusters.
Note: - Function textual ID is "org.opencv.core.kmeansNDNoInit"
Finds centers of clusters and groups input samples around the clusters.
Finds centers of clusters and groups input samples around the clusters.
Calculates the Laplacian of an image.
Performs a look-up table transform of a matrix.
Converts an image from LUV color space to BGR color space.
Applies a mask to a matrix.
Describe matrix depth, channels, size, planar layout and tensor dimensions for custom graph metadata callbacks.
Calculates per-element maximum of two matrices.
Calculates an average (mean) of matrix elements.
Blurs an image using the median filter.
Creates one 3-channel matrix out of 3 single-channel ones.
gapi_matrixop
gapi_pixelwise
Performs advanced morphological transformations.
Calculates the per-element scaled product of two matrices.
Multiplies matrix by scalar.
Multiplies matrix by scalar.
Multiplies matrix by scalar.
Create a native network package from an array of OpenCV DNN parameter objects. Tags must be unique. The namespaced `cv.gapi.networks` adapter instead takes separate arguments.
Normalizes the norm or value range of an array.
Calculates the absolute infinite norm of a matrix.
Calculates the absolute L1 norm of a matrix.
Calculates the absolute L2 norm of a matrix.
Converts an image from NV12 (YUV420p) color space to BGR.
Converts an image from NV12 (YUV420p) color space to gray-scaled.
Converts an image from NV12 (YUV420p) color space to RGB.
gapi_oak_ColorCameraParams_BoardSocket: FIXME: extend
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
gapi_oak_ColorCameraParams_Resolution: FIXME: extend
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Encoding profile, H264, H265 or MJPEG
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Rate control mode specifies if constant or variable bitrate should be used (H264 / H265)
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
This structure provides functions
This structure provides functions
This structure provides functions
This structure provides functions
This structure provides functions
Create network parameter configuration. These parameter objects describe an optional OpenVINO or ONNX Runtime backend, which is not linked in this WASM build. Use gapi.dnn.Params f
NB: Used by python wrapper
Native enum entries for gapi onnx trait as. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
This namespace contains G-API Operation Types for
gapi ot object tracker params value in the OpenCV API.
Tracks objects with video frames.
Tracks objects with video frames. Overload of track(...) for frame as GFrame.
enum: TrackingStatus
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Create network parameter configuration. These parameter objects describe an optional OpenVINO or ONNX Runtime backend, which is not linked in this WASM build. Use gapi.dnn.Params f
Create network parameter configuration. These parameter objects describe an optional OpenVINO or ONNX Runtime backend, which is not linked in this WASM build. Use gapi.dnn.Params f
NB: Used by python wrapper
namespace nn
Parses output of SSD network.
Parses output of Yolo network.
Calculates the rotation angle of 2D vectors.
Calculates x and y coordinates of 2D vectors from their magnitude and angle.
Applies a generic geometrical transformation to an image.
This namespace contains G-API CPU rendering backend functions,
gapi_colorconvert
Converts an image from RGB color space to gray-scaled.
Resulting gray color value computed as
Converts an image from RGB color space to HSV.
Converts an image from RGB color space to I420 color space.
Converts an image from RGB color space to Lab color space.
Converts an image from RGB color space to YUV color space.
Converts an image from RGB color space to YUV422.
Select values from either first or second of input matrices by given mask.
namespace imgproc
Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
Divides a 3-channel matrix into 3 single-channel matrices.
Divides a 4-channel matrix into 4 single-channel matrices.
Calculates a square root of array elements.
The enum specified format of result that you get from `cv::gapi::stereo.`
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Specify queue capacity for streaming execution.
Create an opaque signed 64-bit graph node reading the source sequence identifier. Use it on an input node; GraphStream numbers frames from zero unless metadata overrides it.
Create an opaque signed 64-bit sequence-number node. This is an alias for the native sequence metadata operation.
Gets dimensions from Mat.
Gets dimensions from rectangle.
Gets dimensions from Mat.
Native enum entries for gapi streaming sync policy. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Create an opaque signed 64-bit graph node reading the source timestamp in microseconds. Use it on an input node and supply metadata with applyWithMetadata or GraphStream.
Calculates the per-element difference between two matrices.
Calculates the per-element difference between matrix and given scalar.
Calculates the per-element difference between given scalar and the matrix.
Calculates sum of all matrix elements.
Applies a fixed-level threshold to each matrix element.
This function applicable for all threshold types except cv::THRESH_OTSU and cv::THRESH_TRIANGLE
Transposes a matrix.
This namespace contains G-API Operations and functions for
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Applies an affine transformation to an image.
Applies a perspective transformation to an image.
This structure represents a circle to draw.
This structure represents an image to draw.
This structure represents a line to draw.
This structure represents a mosaicing operation.
This structure represents a polygon to draw.
This structure represents a rectangle to draw.
The function renders on the input image passed drawing primitivies
Render drawing primitives in place on the supplied Y and UV planes of an NV12 image.
Renders on 3 channels input
Renders on two planes
This structure represents a text string to draw.
gapi wip gst gstreamer pipeline value in the OpenCV API.
Indicates what type of data should be produced by GStreamerSource: cv::MediaFrame or cv::Mat
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for gapi wip onevpl accel type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Converts an image from YUV color space to BGR color space.
Converts an image from YUV color space to RGB.
A typed array graph node for bool values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for double values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for float values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for int values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for int64 t values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for mat values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for point2f values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for point2i values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for point3f values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for prim values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for rect values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for scalar values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for size values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for string values. It describes graph data; execution receives and returns ordinary arrays.
A typed array graph node for uint64 t values. It describes graph data; execution receives and returns ordinary arrays.
\addtogroup gapi_meta_args
Blurs an image using a Gaussian filter.
An owned native graph compilation option. Wrap a kernel package or use a static factory for network and queue options.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
namespace gapi
An owned native drawing primitive used in typed graph arrays. Construct it from a supported drawing shape and release it after use.
Performs generalized matrix multiplication.
generalized matrix multiplication flags
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
finds arbitrary template in the grayscale image using Generalized Hough Transform
finds arbitrary template in the grayscale image using Generalized Hough Transform
finds arbitrary template in the grayscale image using Generalized Hough Transform
Calculates an affine transform from three pairs of the corresponding points.
Returns full configuration time cmake output.
example: samples/python/snippets/fitline.py
Returns list of CPU features enabled during compilation.
Returns the number of CPU ticks.
Returns AlgorithmHint defined during OpenCV compilation. Defines #ALGO_HINT_DEFAULT behavior.
Returns the default new camera matrix.
Returns filter coefficients for computing spatial image derivatives.
Calculates the font-specific size to use to achieve a given height in pixels.
Returns Gabor filter coefficients.
imgproc_feature
Returns feature name by ID
Returns the number of logical CPUs available for the process.
Returns the number of threads used by OpenCV for parallel regions.
Returns the optimal DFT size for a given vector size.
Returns the new camera intrinsic matrix based on the free scaling parameter.
Named return value and scalar output parameters from getOptimalNewCameraMatrix. Matrix and vector output arguments are filled in place.
Calculates a perspective transform from four pairs of the corresponding points.
Retrieves a pixel rectangle from an image with sub-pixel accuracy.
Calculates an affine matrix of 2D rotation.
Returns a structuring element of the specified size and shape for morphological operations.
Calculates the width and height of a text string.
Calculates the bounding rect for the text
Named return value and scalar output parameters from getTextSize. Matrix and vector output arguments are filled in place.
Returns the index of the currently executed thread within the current parallel region. Always
Returns the number of ticks.
Returns the number of ticks per second.
computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by #stereoRectify)
Returns major library version
Returns minor library version
Returns revision field of the library version
Returns library version string
Native enum entries for gfluid kernel kind. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\addtogroup gapi_data_objects
Wrapping class for feature detection using the goodFeaturesToTrack function. :
Create an owned GFTTDetector instance with the supplied configuration.
Create an owned GFTTDetector instance with the supplied configuration.
Declare the graph input protocol from native graph nodes in execution order. Dispose the returned protocol handle.
Named matrix graph inputs for native graph inference. Construct it, set model input names, then pass it to `cv.gapi.infer`.
Named region or prepared-tensor graph lists for `cv.gapi.infer2`. Every list in one execution must have the same length.
Named lists of tensor output nodes from region/list inference. Request output names before constructing the computation.
Named matrix output nodes of an inference operation. Obtain this object through `cv.gapi.infer`, then request all output names before constructing the computation.
namespace gapi
\addtogroup gapi_data_objects
\addtogroup gapi_meta_args
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Determines strong corners on an image.
Same as above, but returns also quality measure of the detected corners.
Same as above, but returns also quality measure of the detected corners.
A graph node carrying one bool value. It holds a graph relationship rather than a runtime value.
A graph node carrying one double value. It holds a graph relationship rather than a runtime value.
A graph node carrying one float value. It holds a graph relationship rather than a runtime value.
A graph node carrying one int value. It holds a graph relationship rather than a runtime value.
A graph node carrying one int64 t value. It holds a graph relationship rather than a runtime value.
A graph node carrying one point value. It holds a graph relationship rather than a runtime value.
A graph node carrying one point2f value. It holds a graph relationship rather than a runtime value.
A graph node carrying one point3f value. It holds a graph relationship rather than a runtime value.
A graph node carrying one rect value. It holds a graph relationship rather than a runtime value.
A graph node carrying one size value. It holds a graph relationship rather than a runtime value.
A graph node carrying one string value. It holds a graph relationship rather than a runtime value.
A graph node carrying one uint64 t value. It holds a graph relationship rather than a runtime value.
\addtogroup gapi_meta_args
A native custom operation with matrix inputs and outputs. Its metadata callback determines the preallocated output layouts.
Declare the graph output protocol from native graph nodes in result order. Dispose the returned protocol handle.
An owned input protocol listing the graph nodes accepted by a computation, in execution order.
An owned output protocol listing the nodes returned by a graph computation, in result order.
example: samples/cpp/grabcut.cpp
class of the pixel in GrabCut algorithm
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
GrabCut algorithm flags
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Only matrix ports need a layout. Other ports have null metadata.
Explicit image preprocessing for a named DNN graph input. Omit cfgInput for raw float tensors.
One graph input batch. A release callback transfers responsibility for temporary input handles.
Signed 64-bit source metadata. Timestamps are microseconds since the Unix epoch by default.
Iterables borrow their values unless a frame supplies a release callback.
graphical code detector value in the OpenCV API.
Synchronous CPU kernel. Matrices are borrowed; write into preallocated outputs without resizing them.
Matrix layout passed by value to custom graph metadata callbacks.
Derive output layouts from input layouts before allocating graph buffers.
A placeholder describing an input, intermediate value or output of a native graph. Supply runtime values to GComputation.apply instead of passing these nodes as pixel data.
Native graph nodes in the order declared by a custom operation.
Native node and callback value types for each supported custom graph port.
A nonempty tuple of graph port names, inferred from a literal operation signature.
Supported port names for custom native graph operations: matrices, four-component scalars, typed arrays and typed opaque values.
Pull frames serially. Honor the abort signal when waiting for an external producer.
Serial graph execution over frame sources. Use await using or await delete() to release retained handles.
Serial frame executor. Dispose with await using or await delete().
Synchronous callback; assign values into outputs and borrow native handles until return.
Null marks metadata for a scalar, array or opaque value.
Graph inputs and outputs supported by the native graph executor.
Runtime values in the order declared by a custom operation.
Groups the object candidate rectangles.
\addtogroup gapi_data_objects
\addtogroup gapi_meta_args
namespace detail
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\addtogroup gapi_main_classes
A native custom operation supporting matrix, scalar, typed array and opaque ports. Prefer `cv.gapi.op` for exact tuple inference.
Native enum entries for hand eye calibration method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Checks for the presence of at least one non-zero array element.
A simple Hausdorff distance measure between shapes defined by contours
Checks if the specified image file can be decoded by OpenCV.
Checks if the specified image file or specified file extension can be encoded by OpenCV.
```cpp
Hierarchical Data Format version 5 interface.
Named return value and scalar output parameters from hdf_HDF5_atread1. Matrix and vector output arguments are filled in place.
Named return value and scalar output parameters from hdf_HDF5_atread2. Matrix and vector output arguments are filled in place.
Named return value and scalar output parameters from hdf_HDF5_atread. Matrix and vector output arguments are filled in place.
Open or create hdf5 file
Only a subset of Hershey fonts <https://en.wikipedia.org/wiki/Hershey_fonts> are supported
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
The opencv hfs module contains an efficient algorithm to segment an image.
: create a hfs object
imgproc_feature
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Abstract base class for histogram cost algorithms.
Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector.
Native enum entries for hogdescriptor descriptor storage format. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/hog_tapi.cpp
Returns coefficients of the classifier trained for people detection (for 64x128 windows).
Native enum entries for hogdescriptor histogram norm type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp
Finds circles in a grayscale image using the Hough transform and get accumulator.
example: samples/cpp/tutorial_code/ImgTrans/houghlines.cpp
Finds line segments in a binary image using the probabilistic Hough transform.
Finds lines in a set of points using the standard Hough transform.
Finds lines in a binary image using the standard Hough transform and get accumulator.
imgproc_shape
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates seven Hu invariants.
Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
Applying an appropriate non-linear transformation to the gradient field inside the selection and
Native enum entries for image metadata type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Returns the number of images inside the given file
Reads an image from a buffer in memory.
Loads frames from an animated image buffer into an Animation structure.
Reads a multi-page image from a buffer in memory.
Reads an image from a memory buffer and extracts associated metadata.
Encodes an image into a memory buffer.
Encodes an Animation to a memory buffer.
Encodes array of images into a memory buffer.
Encodes an image into a memory buffer.
Calculates img_hash::AverageHash in one call
Computes average hash value of the input image
Create an owned img_hash_AverageHash instance with the supplied configuration.
Computes block mean hash of the input image
Image hash based on block mean.
Create an owned img_hash_BlockMeanHash instance with the supplied configuration.
Native enum entries for img hash block mean hash mode. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Computes color moment hash of the input, the algorithm
Image hash based on color moments.
Create an owned img_hash_ColorMomentHash instance with the supplied configuration.
The base class for image hash algorithms
Computes average hash value of the input image
Marr-Hildreth Operator Based Hash, slowest but more discriminative.
Create an owned img_hash_MarrHildrethHash instance with the supplied configuration.
Computes pHash value of the input image
pHash
Create an owned img_hash_PHash instance with the supplied configuration.
Computes radial variance hash of the input image
Image hash based on Radon transform.
Create an owned img_hash_RadialVarianceHash instance with the supplied configuration.
Loads an image from a file.
Loads an image from a file.
example: samples/cpp/tutorial_code/imgcodecs/animations.cpp
Imread flags
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Loads a multi-page image from a file.
Loads images of a multi-page image from a file.
Reads an image from a file along with associated metadata.
Saves an image to a specified file.
Saves an Animation to a specified file.
Imwrite BMP specific values for IMWRITE_BMP_COMPRESSION parameter key.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for imwrite exrcompression flags. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for imwrite exrtype flags. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
ImwriteFlags: Imwrite flags
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Imwrite GIF specific values for IMWRITE_GIF_QUALITY parameter key, if larger than 3, then its related to the size of the color table.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Imwrite HDR specific values for IMWRITE_HDR_COMPRESSION parameter key
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for imwrite jpegsampling factor params. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Encode and save multiple images to a supported multi-page format in the virtual filesystem. Return whether encoding succeeded.
Imwrite PAM specific tupletype flags used to define the 'TUPLETYPE' field of a PAM file.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Imwrite PNG specific values for IMWRITE_PNG_FILTER parameter key
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Imwrite PNG specific flags used to tune the compression algorithm.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for imwrite tiff compression flags. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for imwrite tiff predictor flags. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for imwrite tiff resolution unit flags. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Imwrite WEBP specific values for IMWRITE_WEBP_LOSSLESS_MODE parameter key.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Saves an image to a specified file with metadata
Finds an initial camera intrinsic matrix from 3D-2D point correspondences.
Computes the projection and inverse-rectification transformation map. In essense, this is the inverse of
Initialize the shared OpenCV instance used by named imports such as Mat and GaussianBlur.
Computes the undistortion and rectification transformation map.
Restores the selected region in an image using the region neighborhood.
Checks if array elements lie between the elements of two other arrays.
Inserts a single channel to dst (coi is 0-based index)
Install the streaming adapter on this instance's computation prototype.
An integer and double-precision number passed together as a plain JavaScript value.
imgproc_transform
imgproc_transform
imgproc_transform
Given an input bgr or grayscale image, apply autoscaling on domain [0, 255] to increase
Given an input color image, enhance low-light images using the BIMEF method ([ying2017bio] [ying2017new]).
Given an input color image, enhance low-light images using the BIMEF method ([ying2017bio] [ying2017new]).
Given an input bgr or grayscale image, apply linear contrast stretching on domain [0, 255]
Given an input bgr or grayscale image and constant gamma, apply power-law transformation,
Given an input bgr or grayscale image and constant c, apply log transformation to the image
imgproc_filter
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for interpolation masks. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/snippets/intersectExample.cpp
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Finds the inverse or pseudo-inverse of a matrix.
Inverts an affine transformation.
Query the native Intel IPP configuration. Intel IPP acceleration is not linked in this WASM build.
Set the native Intel IPP preference. Intel IPP acceleration is not linked in this WASM build, so this does not enable an accelerator.
Set the native Intel IPP preference. Intel IPP acceleration is not linked in this WASM build, so this does not enable an accelerator.
proxy for hal::Cholesky
IPP Not-Exact mode. This function may force use of IPP then both IPP and OpenCV provide proper results
Tests a contour convexity.
OBSENSOR
example: samples/cpp/snippets/kalman.cpp
namespace
This method converts vector of keypoints to vector of points or the reverse, where each keypoint is
Convert point coordinates into keypoints with the supplied shared size, response, octave and class identifier.
This method computes overlap for pair of keypoints. Overlap is the ratio between area of keypoint
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
KinectFusion implementation
Create an owned kinfu_KinFu instance with the supplied configuration.
Length of single raycast step
Coarse parameters
ColoredTSDF parameters
Default parameters
HashTSDF parameters
kinfu volume params value in the OpenCV API.
example: samples/cpp/snippets/kmeans.cpp
core_array
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/snippets/laplace.cpp
Large Scale Dense Depth Fusion implementation
Create an owned large_kinfu_LargeKinfu instance with the supplied configuration.
large kinfu params value in the OpenCV API.
Coarse parameters
Default parameters
HashTSDF parameters
large kinfu volume params value in the OpenCV API.
Coarse set of parameters that provides relatively higher performance at the cost of reconstrution quality.
Default set of parameters that provide higher quality reconstruction at the cost of slow performance.
MultiTracker Class ---By Laksono Kurnianggoro---)
Returns a pointer to a new instance of MultiTracker
Tracker Base Class
Named return value and scalar output parameters from legacy_Tracker_update. Matrix and vector output arguments are filled in place.
the Boosting tracker
legacy_TrackerBoosting_create: Constructor
CSRT
legacy_TrackerCSRT_create: Constructor
the KCF (Kernelized Correlation Filter) tracker
legacy_TrackerKCF_create: Constructor
the Median Flow tracker
legacy_TrackerMedianFlow_create: Constructor
Specific Tracker Classes
legacy_TrackerMIL_create: Constructor
the MOSSE (Minimum Output Sum of Squared %Error) tracker
legacy_TrackerMOSSE_create: Constructor
the TLD (Tracking, learning and detection) tracker
legacy_TrackerTLD_create: Constructor
Wrap a legacy single-object tracker with the newer Tracker interface and return an owned handle.
LightGlue feature matcher.
Creates LightGlueMatcher from a model file path.
Create an owned LightGlueMatcher instance with the supplied configuration.
Draws a line segment connecting two points.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Class implements both functionalities for detection of lines and computation of their
Create a BinaryDescriptor object with default parameters (or with the ones provided)
furnishes all functionalities for querying a dataset provided by user or internal to
Draws keylines.
Draws the found matches of keylines from two images.
--------------------------------------------------------------------------------------------
A class to represent a line
line descriptor lsddetector value in the OpenCV API.
Creates ad LSDDetector object, using smart pointers.
Create an owned line_descriptor_LSDDetector instance with the supplied configuration.
Lines extraction methodology
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Modality that computes quantized gradient orientations from a color image.
linemod_ColorGradient_create: Constructor.
Debug function to colormap a quantized image for viewing.
Modality that computes quantized surface normals from a dense depth map.
linemod_DepthNormal_create: Constructor.
Object detector using the LINE template matching algorithm with any set of
Named return value and scalar output parameters from linemod_Detector_addTemplate. Matrix and vector output arguments are filled in place.
Debug function to draw linemod features
Discriminant feature described by its location and label.
Factory function for detector using LINE algorithm with color gradients.
Factory function for detector using LINE-MOD algorithm with color gradients
Represents a successful template match.
Interface for modalities that plug into the LINE template matching representation.
Create modality by name.
Create modality by name.
Represents a modality operating over an image pyramid.
linemod template value in the OpenCV API.
imgproc_hist
Variants of Line Segment %Detector
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
LineTypes: types of line
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Load chromatic-aberration calibration parameters from opened FileStorage.
Named return value and scalar output parameters from loadChromaticAberrationParams. Matrix and vector output arguments are filled in place.
Loads a mesh from a file.
Loads a point cloud from a file.
Native enum entries for local optim method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates the natural logarithm of every array element.
example: samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
Calculates the magnitude of 2D vectors.
Calculates the Mahalanobis distance between two vectors.
Convert a synchronous or asynchronous iterable to a source with explicit end-of-stream cleanup.
An owned native map with typed keys and values. Use get, set, keys and size to access its entries, and delete to release it.
An owned native map with typed keys and values. Use get, set, keys and size to access its entries, and delete to release it.
An owned native map with typed keys and values. Use get, set, keys and size to access its entries, and delete to release it.
An owned native map with typed keys and values. Use get, set, keys and size to access its entries, and delete to release it.
Possible set of marker types used for the cv::drawMarker function
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/cout_mat.cpp
Compares two shapes.
example: samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp
Copy row-major interleaved values into an owned native matrix on the shared engine.
Copy canvas RGBA bytes into an owned CV_8UC4 matrix on the initialized shared engine. Dispose after use.
Computes partial derivatives of the matrix product for each multiplied matrix.
Type of matrix used in LevMarq solver
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An owned OpenCV 5 tensor shape with up to ten dimensions and layout metadata. Construct from an IntVector, or use scalar() for a zero-dimensional tensor. Dispose the shape after us
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Allocate an owned matrix with arbitrary tensor dimensions supplied in an IntVector and an OpenCV element type. Fill it through the typed pixel views.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Calculates per-element maximum of two arrays or an array and a scalar.
CChecker
Create a new CChecker object.
A class to find the positions of the ColorCharts in the image.
Returns the implementation of the CCheckerDetector.
Set the net which will be used to find the approximate
ColorChart
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
struct DetectorParametersMCC is used by CCheckerDetector
Calculates an average (mean) of array elements.
example: samples/cpp/snippets/camshiftdemo.cpp
Calculates a mean and standard deviation of array elements.
Native enum entries for media format. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
This enum defines different types of cv::MediaFrame provided
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp
Creates one multi-channel array out of several single-channel ones.
The resulting HDR image is calculated as weighted average of the exposures considering exposure
The base class algorithms that can merge exposure sequence to a single image.
Pixels are weighted using contrast, saturation and well-exposedness measures, than images are
The resulting HDR image is calculated as weighted average of the exposures considering exposure
Calculates per-element minimum of two arrays or an array and a scalar.
Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
Finds a circle of the minimum area enclosing a 2D point set.
Finds a convex polygon of minimum area enclosing a 2D point set and returns its area.
Finds a triangle of minimum area enclosing a 2D point set and returns its area.
Finds the global minimum and maximum in an array.
Minimum and maximum values and their two-dimensional locations returned by a matrix reduction.
Copies specified channels from input arrays to the specified channels of
\
possible activation functions
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Creates empty model
Loads and creates a serialized ANN from a file
ml_ANN_MLP_TrainFlags: Train options
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Available training methods
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\
Creates the empty model.
Loads and creates a serialized Boost from a file
Boosting type.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\
Creates the empty model
Predict options
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Loads and creates a serialized DTrees from a file
\
Creates empty %EM model.
Loads and creates a serialized EM from a file
Type of covariation matrices
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
ml_ErrorTypes: %Error types
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\
Creates the empty model
Loads and creates a serialized knearest from a file
Implementations of KNearest algorithm
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\
Creates empty model.
Loads and creates a serialized LogisticRegression from a file
Training methods
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Regularization kinds
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\
Creates empty model
Loads and creates a serialized NormalBayesClassifier from a file
The structure represents the logarithmic grid range of statmodel parameters.
Creates a ParamGrid Ptr that can be given to the %SVM::trainAuto method
\
Creates the empty model.
Loads and creates a serialized RTree from a file
ml_SampleTypes: Sample types
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Base class for statistical models in OpenCV ML.
Predict options
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\
Creates empty model.
Generates a grid for %SVM parameters.
%SVM kernel type
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Loads and creates a serialized svm from a file
%SVM params type
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
ml_SVM_Types: %SVM type
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\
Creates empty model.
Loads and creates a serialized SVMSGD from a file
ml_SVMSGD_MarginType: Margin type.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
SVMSGD type.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Class encapsulating training data.
Creates training data from in-memory arrays.
Extract from matrix rows/cols specified by passed indexes.
Extract from 1D vector elements specified by passed indexes.
ml_VariableTypes: Variable types
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates all of the moments up to the third order of a polygon or rasterized shape.
core_basic
returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.
Performs advanced morphological transformations.
shape of the structuring element
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
type of morphological operation
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates a global motion orientation in a selected region.
Calculates a gradient orientation of a motion history image.
Splits a motion history image into a few parts corresponding to separate independent motions (for
Updates the motion history image by a moving silhouette.
example: samples/python/snippets/mser.py
Full constructor for %MSER detector
Represents the algorithms available for building a Minimum Spanning Tree (MST).
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Represents an edge in a graph for Minimum Spanning Tree (MST) computation.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Performs the per-element multiplication of two Fourier spectrums.
Calculates the per-element scaled product of two arrays.
Calculates the product of a matrix and its transposition.
Native enum entries for neighbor search method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
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.
A norm based cost extraction. :
norm types
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Octree for 3D vision.
Create an Octree from the PointCloud data with the specific maxDepth
Create an owned Octree instance with the supplied configuration.
Create an Octree from the PointCloud data with the specific resolution
Create an owned Octree instance with the supplied configuration.
odometry value in the OpenCV API.
These constants are used to set the speed and accuracy of odometry
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An object that keeps per-frame data for Odometry algorithms from user-provided images to algorithm-specific precalculated data.
Indicates what pyramid is to access using getPyramidAt() method:
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
odometry settings value in the OpenCV API.
These constants are used to set a type of data which odometry will use
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Perform omnidirectional camera calibration, the default depth of outputs is CV_64F.
Computes undistortion and rectification maps for omnidirectional camera image transform by a rotation R.
This module was accepted as a GSoC 2015 project for OpenCV, authored by
Stereo calibration for omnidirectional camera model. It computes the intrinsic parameters for two
Stereo 3D reconstruction from a pair of images
Stereo rectification for omnidirectional camera model. It computes the rectification rotations for two cameras
Undistort omnidirectional images to perspective images
Undistort 2D image points for omnidirectional camera using CMei's model
All native functions, classes, constants and enums in this build.
Loading options; use wasmUrl with bundlers or wasmBinary for an in-memory binary.
Fast dense optical flow computation based on robust local optical flow (RLOF) algorithms and sparse-to-dense interpolation scheme.
Calculate an optical flow using "SimpleFlow" algorithm.
Calculate an optical flow using "SimpleFlow" algorithm.
Calculates fast optical flow for a sparse feature set using the robust local optical flow (RLOF) similar
Fast dense optical flow based on PyrLK sparse matches interpolation.
DeepFlow optical flow algorithm implementation.
Additional interface to the Dense RLOF algorithm - optflow::calcOpticalFlowDenseRLOF()
Creates instance of cv::DenseOpticalFlow
Additional interface to the Farneback's algorithm - calcOpticalFlowFarneback()
Creates an instance of PCAFlow
Additional interface to the SimpleFlow algorithm - calcOpticalFlowSF()
Additional interface to the Sparse RLOF algorithm - optflow::calcOpticalFlowSparseRLOF()
Additional interface to the SparseToDenseFlow algorithm - calcOpticalFlowSparseToDense()
Fast dense optical flow computation based on robust local optical flow (RLOF) algorithms and sparse-to-dense interpolation
Creates instance of optflow::DenseRLOFOpticalFlow
"Dual TV L1" Optical Flow Algorithm.
Creates instance of cv::DualTVL1OpticalFlow
Descriptor types for the Global Patch Collider.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Find correspondences between two images.
optflow gpcpatch descriptor value in the OpenCV API.
optflow gpcpatch sample value in the OpenCV API.
Class encapsulating training samples.
Class for individual tree.
Native enum entries for optflow interpolation type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
PCAFlow algorithm.
This class can be used for imposing a learned prior on the resulting optical flow.
This is used store and set up the parameters of the robust local optical flow (RLOF) algoritm.
Creates instance of optflow::RLOFOpticalFlowParameter
Native enum entries for optflow solver type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Class used for calculation sparse optical flow and feature tracking with robust local optical flow (RLOF) algorithms.
Creates instance of SparseRLOFOpticalFlow
Native enum entries for optflow support region type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor
The ORB constructor
Native enum entries for orb score type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Change OpenCV parallel_for backend
Native enum entries for param. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Replaces NaNs (Not-a-Number values) in a matrix with the specified value.
Principal Component Analysis
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
wrap PCA::backProject
wrap PCA::operator()
wrap PCA::operator()
wrap PCA::operator() and add eigenvalues output parameter
wrap PCA::operator() and add eigenvalues output parameter
wrap PCA::project
example: samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp
Performs the perspective matrix transformation of vectors.
Calculates the rotation angle of 2D vectors.
Class implementing two-dimensional phase unwrapping based on [histogramUnwrapping]
phase_unwrapping_HistogramPhaseUnwrapping_create: Constructor
Parameters of phaseUnwrapping constructor.
Abstract base class for phase unwrapping.
example: samples/cpp/snippets/phase_corr.cpp
Detects translational shifts between two images.
Named return value and scalar output parameters from phaseCorrelate. Matrix and vector output arguments are filled in place.
plot plot2d value in the OpenCV API.
Creates Plot2d object
Creates Plot2d object
A two-dimensional coordinate value with numeric components. No native disposal is required.
A two-dimensional coordinate value with numeric components. No native disposal is required.
A two-dimensional coordinate value with numeric components. No native disposal is required.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
A three-dimensional coordinate value with numeric components. No native disposal is required.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Performs a point-in-contour test.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Calculates x and y coordinates of 2D vectors from their magnitude and angle.
Native enum entries for polishing method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Draws several polygonal curves.
Raises every array element to a power.
Adds a uniform noise in the given scale to the input point cloud
Compute the normals of an arbitrary point cloud
Generate a random 4x4 pose matrix
This class implements a very efficient and robust variant of the iterative closest point (ICP) algorithm.
Named return value and scalar output parameters from ppf_match_3d_ICP_registerModelToScene. Matrix and vector output arguments are filled in place.
Load a PLY file
Class, allowing the storage of a pose. The data structure stores both
When multiple poses (see Pose3D) are grouped together (contribute to the same transformation)
Class, allowing the load and matching 3D models.
Sample a point cloud using uniform steps
Transforms the point cloud with a given a homogeneous 4x4 pose matrix (in double precision)
Write a point cloud to PLY file
Used for debbuging pruposes, writes a point cloud to a PLY file with the tip
Calculates a feature map for corner detection.
Projects 3D points to an image plane.
Projects 3D points to an image plane.
Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Draws a text string.
Draws a text string using specified font.
Defines various put text flags
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
imgproc_misc
imgproc_segmentation
py rotation warper value in the OpenCV API.
Upsamples an image and then blurs it.
QR code detector.
QR code detector based on Aruco markers detection code.
qrcode detector aruco params value in the OpenCV API.
QR code encoder.
Native enum entries for qrcode encoder correction level. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
QRCodeEncoder_create: Constructor
Native enum entries for qrcode encoder eciencodings. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for qrcode encoder encode mode. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
QR code encoder parameters.
Quality Base Class
BRISQUE (Blind/Referenceless Image Spatial Quality Evaluator) is a No Reference Image Quality Assessment (NR-IQA) algorithm.
static method for computing quality
static method for computing image features used by the BRISQUE algorithm
Create an object which calculates quality
Create an object which calculates quality
Full reference GMSD algorithm
static method for computing quality
Create an object which calculates image quality
Full reference mean square error algorithm https://en.wikipedia.org/wiki/Mean_squared_error
static method for computing quality
Create an object which calculates quality
Full reference peak signal to noise ratio (PSNR) algorithm https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
static method for computing quality
Create an object which calculates quality
Full reference structural similarity algorithm https://en.wikipedia.org/wiki/Structural_similarity
static method for computing quality
Create an object which calculates quality
Unit quaternion flag
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Enum of Euler angles type.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Fills the array with normally distributed random numbers.
Shuffles the array elements randomly.
Generates a single uniformly-distributed random number or an array of random numbers.
Half-open integer interval [start, end), used to select matrix rows and columns.
Collect corresponding 2d and 3d points based on correspondencies and mask
Debug draw markers of matched correspondences onto a lineBundle
Debug draw search lines onto an image
Draw a wireframe of a triangle mesh
Extract control points from the projected silhouette of a mesh
Extract the line bundle from an image
Find corresponding image locations by searching for a maximal sobel edge along the search line (a single
implements "Global optimal searching for textureless 3D object tracking" [wang2015global]
Create an owned rapid_OLSTracker instance with the supplied configuration.
implements "Optimal local searching for fast and robust textureless 3D object tracking in highly
Create an owned rapid_OLSTracker instance with the supplied configuration.
High level function to execute a single rapid [harris1990rapid] iteration
wrapper around `rapid` function for uniform access
Create an owned rapid_Rapid instance with the supplied configuration.
Named return value and scalar output parameters from rapid_rapid. Matrix and vector output arguments are filled in place.
Abstract base class for stateful silhouette trackers
Read a .flo file
Recovers the relative camera rotation and the translation from corresponding points in two images from two different cameras, using chirality check. Returns the number of
Recovers the relative camera rotation and the translation from an estimated essential
Recovers the relative camera rotation and the translation from an estimated essential
Recovers the relative camera rotation and the translation from an estimated essential
An upright rectangle described by its top-left x/y and width/height. No native disposal is required.
An upright rectangle described by its top-left x/y and width/height. No native disposal is required.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An upright rectangle described by its top-left x/y and width/height. No native disposal is required.
Draws a simple, thick, or filled up-right rectangle.
use `rec` parameter as alternative specification of the drawn rectangle: `r.tl() and
Finds out if there is any intersection between two rectangles
types of intersection between rectangles
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Reduces a matrix to a vector.
Finds indices of max elements along provided axis
Finds indices of min elements along provided axis
Native enum entries for reduce types. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Base class for modelling a Map between two images.
Defines an affine transformation
Base class for modelling an algorithm for calculating a map
Mapper for affine motion
Mapper for euclidean motion: rotation plus shift
Gradient mapper for a projective transformation
Gradient mapper for a translation
Calculates a similarity transformation between to images (scale, rotation, and shift)
Calculates a map using a gaussian pyramid
Defines an transformation that consists on a projective transformation
Defines an transformation that consists on a simple displacement
Converts a pointer to a Map returned by MapperPyramid::calculate into the specified Map pointer type
Cast a native registration map to the Affine map interface. The input must contain that map implementation; dispose the returned handle.
Cast a native registration map to the Projec map interface. The input must contain that map implementation; dispose the returned handle.
Cast a native registration map to the Shift map interface. The input must contain that map implementation; dispose the returned handle.
Calibrates a camera pair set up. This function finds the extrinsic parameters between the two cameras.
Calibrates a camera pair set up. This function finds the extrinsic parameters between the two cameras.
Registers depth data to an external camera
Applies a generic geometrical transformation to an image.
Fills the output array with repeated copies of the input array.
Reprojects a disparity image to 3D space.
If the input image is of type CV_16UC1 (like the Kinect one), the image is converted to floats, divided
Create an owned matrix header with new channel count and tensor dimensions without copying pixels. The total element count must stay unchanged and native continuity rules apply.
imgproc_filter
mode of the contour retrieval algorithm
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Object that can compute the normals in an image.
Creates new RgbdNormals object
Native enum entries for rgbd normals rgbd normals method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for rgbd plane method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
\addtogroup gapi_data_structures
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for robot world hand eye calibration method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Converts a rotation matrix to a rotation vector or vice versa.
Rotates a 2D array in multiples of 90 degrees.
namespace
Finds out if there is any intersection between two rotated rectangles.
Return the smallest upright integer rectangle containing the rotated rectangle.
Return the upright floating-point bounds of the rotated rectangle.
Return the four corners of a rotated rectangle as independent point values.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Broadcast the given Mat to the given shape.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Computes an RQ decomposition of 3x3 matrices.
type of the robust estimation algorithm
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Native enum entries for sac model type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Motion Saliency Base Class
Specific Motion Saliency Specialized Classes
Create an owned saliency_MotionSaliencyBinWangApr2014 instance with the supplied configuration.
Objectness Base Class
Specific Objectness Specialized Classes
Create an owned saliency_ObjectnessBING instance with the supplied configuration.
Saliency Base Class
Static Saliency Base Class
the Fine Grained Saliency approach from [FGS]
Create an owned saliency_StaticSaliencyFineGrained instance with the supplied configuration.
Specific Static Saliency Specialized Classes
Create an owned saliency_StaticSaliencySpectralResidual instance with the supplied configuration.
Override search data path by adding new search location
Append samples search data sub directory
This section describes utility functions for OpenCV samples.
Look for a sample file and return its resolved path, or keep the original filename if no match is found.
Native enum entries for sampling method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates the Sampson Distance between two points.
Saves a mesh to a specified file.
Saves a point cloud to a specified file.
Four numeric channel components. Unused components should be zero; image color order depends on the receiving operation.
Calculates the sum of a scaled array and another array.
Calculates the first x- or y- image derivative using Scharr operator.
Native enum entries for score method. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp
photo_decolor
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Intelligent Scissors image segmentation
Applies a separable linear filter to an image.
Initializes a scaled identity matrix.
OpenCV will try to set the number of threads for subsequent parallel regions.
Sets state of default random number generator.
Enables or disables the optimized code.
Apply Transformation to points.
base class BaseSFM declares a common API that would be used in a typical scene reconstruction scenario
Computes Absolute or Exterior Orientation (Pose Estimation) between 2 sets of 3D point.
Returns the depth of a point transformed by a rigid transform.
Get Essential matrix from Fundamental and Camera matrices.
Get Essential matrix from Motion (R's and t's ).
Converts points from Euclidean to homogeneous space. E.g., ((x,y)->(x,y,1))
Estimate robustly the fundamental matrix between two dataset of 2D point (image coords space).
Estimate robustly the fundamental matrix between two dataset of 2D point (image coords space).
Get Essential matrix from Fundamental and Camera matrices.
Get Fundamental matrix from Projection matrices.
Converts point coordinates from homogeneous to euclidean pixel coordinates. E.g., ((x,y,z)->(x/z, y/z))
Import a reconstruction file.
Point conditioning (isotropic).
Get K, R and t from projection matrix P, decompose using the RQ decomposition.
Data structure describing the camera model and its parameters.
Data structure describing the reconstruction options.
Computes the mean and variance of a given matrix along its rows.
Get Motion (R's and t's ) from Essential matrix.
Choose one of the four possible motion solutions from an essential matrix.
Estimate the fundamental matrix between two dataset of 2D point (image coords space).
Normalizes the Fundamental matrix.
This function normalizes points. (isotropic).
This function normalizes points (non isotropic).
Point conditioning (non isotropic).
Get projection matrix P from K, R and t.
Get projection matrices from Fundamental matrix
Computes the relative camera motion between two cameras.
SFMLibmvEuclideanReconstruction class provides an interface with the Libmv Structure From Motion pipeline.
Creates an instance of the SFMLibmvEuclideanReconstruction class. Initializes Libmv.
Returns the 3x3 skew symmetric matrix of a vector.
Reconstructs bunch of points by triangulation.
Implementation of the Shape Context descriptor and matching algorithm
example: modules/shape/samples/shape_example.cpp
Shape matching methods
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Abstract base class for shape transformation algorithms.
Class for extracting keypoints and computing descriptors using the Scale Invariant Feature Transform
Note: The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When
Create SIFT with specified descriptorType.
Signal resampling
HAVE_OPENCV_DNN || CV_DOXYGEN
Flag to enable contour collection.
simple blob detector params value in the OpenCV API.
An extent described by width and height. No native disposal is required.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An extent described by width and height. No native disposal is required.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
example: samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp
Solves one or more linear systems or least-squares problems.
Finds the real roots of a cubic equation.
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).
return codes for cv::solveLP() function
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Finds an object pose ` {}^{c}\mathbf{T}_o ` from 3 3D-2D point correspondences.
example: samples/cpp/tutorial_code/features/Homography/homography_from_camera_displacement.cpp
Finds an object pose ` {}^{c}\mathbf{T}_o ` from 3D-2D point correspondences.
Native enum entries for solve pn pmethod. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Finds an object pose ` {}^{c}\mathbf{T}_o ` from 3D-2D point correspondences using the RANSAC scheme to deal with bad matches.
Finds rotation and translation vector.
Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame
Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame
Finds the real or complex roots of a polynomial equation.
Sorts each row or each column of a matrix.
Native enum entries for sort flags. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Sorts each row or each column of a matrix.
Base interface for sparse optical flow algorithms.
Class used for calculating a sparse optical flow.
Create an owned SparsePyrLKOpticalFlow instance with the supplied configuration.
Calculates the first order image derivative in both x and y using a Sobel operator
Native enum entries for special filter. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Divides a multi-channel array into several single-channel arrays.
Calculates the normalized sum of squares of the pixel values overlapping the filter.
Calculates a square root of array elements.
Blurs an image using the stackBlur.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
\addtogroup xstereo
stereo propagation parameters value in the OpenCV API.
Class containing the methods needed for Quasi Dense Stereo computation.
Create an owned stereo_QuasiDenseStereo instance with the supplied configuration.
Class for computing stereo correspondence using the block matching algorithm, introduced and
Creates StereoBM object
Calibrates a stereo camera set up. This function finds the intrinsic parameters
Calibrates a stereo camera set up. This function finds the intrinsic parameters
Calibrates a stereo camera set up. This function finds the intrinsic parameters
namespace fisheye
Computes rectification transforms for each head of a calibrated stereo camera.
Named return value and scalar output parameters from stereoRectify. Matrix and vector output arguments are filled in place.
Computes a rectification transform for an uncalibrated stereo camera.
The class implements the modified H. Hirschmuller algorithm [HH08] that differs from the original
Creates StereoSGBM object
example: samples/cpp/snippets/stitching.cpp
Creates a Stitcher configured in one of the stitching modes.
Native enum entries for stitcher mode. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
When setting a resolution for stitching, this values is a placeholder
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Class implementing the Gray-code pattern, based on [UNDERWORLD].
structured_light_GrayCodePattern_create: Constructor
Named return value and scalar output parameters from structured_light_GrayCodePattern_getProjPixel. Matrix and vector output arguments are filled in place.
Class implementing Fourier transform profilometry (FTP) , phase-shifting profilometry (PSP)
structured_light_SinusoidalPattern_create: Constructor.
Parameters of SinusoidalPattern constructor
Abstract base class for generating and decoding structured light patterns.
Stylization aims to produce digital imagery with a wide variety of effects not focused on
subdiv2 d value in the OpenCV API.
Named return value and scalar output parameters from Subdiv2D_edgeDst. Matrix and vector output arguments are filled in place.
Named return value and scalar output parameters from Subdiv2D_edgeOrg. Matrix and vector output arguments are filled in place.
Named return value and scalar output parameters from Subdiv2D_findNearest. Matrix and vector output arguments are filled in place.
Named return value and scalar output parameters from Subdiv2D_getVertex. Matrix and vector output arguments are filled in place.
Named return value and scalar output parameters from Subdiv2D_locate. Matrix and vector output arguments are filled in place.
Calculates the per-element difference between two arrays or array and a scalar.
Calculates the sum of array elements.
wrap SVD::backSubst
Singular Value Decomposition
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
wrap SVD::compute
imgproc_color_conversions
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Iteration termination settings: combine COUNT and EPS flags to stop at maxCount iterations or the requested epsilon accuracy.
Criteria type, can be one of: COUNT, EPS or COUNT + EPS
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
base class BaseOCR declares a common API that would be used in a typical text recognition scenario
OCR classifier type
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Compute the different channels to be processed independently in the N&M algorithm [Neumann12].
Create an Extremal Region Filter for the 1st stage classifier of N&M algorithm [Neumann12].
Reads an Extremal Region Filter for the 1st stage classifier of N&M algorithm
Create an Extremal Region Filter for the 2nd stage classifier of N&M algorithm [Neumann12].
Reads an Extremal Region Filter for the 2nd stage classifier of N&M algorithm
Utility function to create a tailored language model transitions table from a given list of words (lexicon).
OCR HMM Decoder
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Utility funtion for scripting
Extracts text regions from image.
Applies the Stroke Width Transform operator followed by filtering of connected components of similar Stroke Widths to return letter candidates. It also chain them by proximity and
Base class for 1st and 2nd stages of Neumann and Matas scene text detection algorithm [Neumann12]. :
Callback with the classifier is made a class.
Find groups of Extremal Regions that are organized as text blocks.
text::erGrouping operation modes
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Allow to implicitly load the default classifier when creating an ERFilter object.
Allow to implicitly load the default classifier when creating an ERFilter object.
Allow to implicitly load the default character classifier when creating an OCRBeamSearchDecoder object.
Allow to implicitly load the default character classifier when creating an OCRHMMDecoder object.
Allow to implicitly load the default character classifier when creating an OCRHMMDecoder object.
Allow to implicitly load the default character classifier when creating an OCRHMMDecoder object.
Tesseract.OcrEngineMode Enumeration
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
OCR BeamSearch Decoder
Callback with the character classifier is made a class.
Creates an instance of the OCRBeamSearchDecoder class. Initializes HMMDecoder.
OCRHMMDecoder class provides an interface for OCR using Hidden Markov Models.
Callback with the character classifier is made a class.
Creates an instance of the OCRHMMDecoder class. Initializes HMMDecoder.
HMM Decoding algorithm (only Viterbi for the moment)
OCRTesseract class provides an interface with the tesseract-ocr API (v3.02.02) in C++.
Creates an instance of the OCRTesseract class. Initializes Tesseract.
Tesseract.PageSegMode Enumeration
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An abstract class providing interface for text detection algorithms
TextDetectorCNN class provides the functionallity of text bounding box detection.
Creates an instance of the TextDetectorCNN class using the provided parameters.
By retaining only the gradients at edge locations, before integrating with the Poisson solver, one
Definition of the transformation
imgproc_motion
type of the threshold operation
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Same as #threshold, but with an optional mask
a Class to measure passing time.
Copy a shared-engine 8-bit matrix to independent RGBA ImageData, handling row strides.
Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range.
Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in
This algorithm transforms image to contrast using gradients on all levels of gaussian pyramid,
This is a global tonemapping operator that models human visual system.
Copy a matrix into an owned CPU-backed UMat. This build does not use an OpenCL device.
Returns the trace of a matrix.
Base abstract class for the long-term tracker
Tracking is an important issue for many computer vision applications in real world scenario.
Create CSRT tracker instance
tracker csrt params value in the OpenCV API.
tracker da siam rpn value in the OpenCV API.
TrackerDaSiamRPN_create: Constructor
TrackerDaSiamRPN_create1: Constructor
tracker da siam rpn params value in the OpenCV API.
the KCF (Kernelized Correlation Filter) tracker
Create KCF tracker instance
Feature type to be used in the tracking grayscale, colornames, compressed color-names
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
tracker kcf params value in the OpenCV API.
The MIL algorithm trains a classifier in an online manner to separate the object from the
Create MIL tracker instance
tracker mil params value in the OpenCV API.
the Nano tracker is a super lightweight dnn-based general object tracking.
TrackerNano_create: Constructor
TrackerNano_create1: Constructor
tracker nano params value in the OpenCV API.
the VIT tracker is a super lightweight dnn-based general object tracking.
TrackerVit_create: Constructor
TrackerVit_create1: Constructor
tracker vit params value in the OpenCV API.
Performs the matrix transformation of every array element.
Transposes a matrix.
Transpose for n-dimensional matrices.
Face culling settings: what faces are drawn after face culling
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
GL compatibility settings
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Renders a set of triangles on a depth and color image
Overloaded version of triangleRasterize() with color-only rendering
Overloaded version of triangleRasterize() with depth-only rendering
Structure to keep settings for rasterization
Triangle fill settings
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
This function reconstructs 3-dimensional points (in homogeneous coordinates) by using
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Ordered graph output nodes returned together by one native graph operation. Dispose each native node handle separately.
Synchronous callback with borrowed matrix/primitive handles. Fill matrices or assign output values.
A native operation with its exact node tuple and callback signature preserved by TypeScript.
Matrix outputs require metadata; purely scalar, array and opaque operations can omit it.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
UMat: todo: document
Comma-separated Matrix Initializer
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
MatAllocator //////////////////////////////////////
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Transforms an image to compensate for lens distortion.
Compute undistorted image points position
Computes the ideal point coordinates from the observed point coordinates.
cv::undistort mode
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
usac params value in the OpenCV API.
Returns the status of optimized code usage.
utils class with keyword properties value in the OpenCV API.
Copy the supplied matrix to the destination and return a diagnostic string describing the named arguments used by OpenCV's binding tests.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Format the supplied value as text using OpenCV's binding diagnostics. Useful for checking how an argument crosses the native boundary.
Return the native sample-download cache path. The path belongs to the WASM virtual filesystem and does not download files by itself.
utils function params value in the OpenCV API.
Generate a vector of sample values for OpenCV binding diagnostics; dispose the returned native vector.
Generate a vector of sample values for OpenCV binding diagnostics; dispose the returned native vector.
Generate a vector of sample values for OpenCV binding diagnostics; dispose the returned native vector.
Get global logging level
Supported logging levels and their semantic
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Set global logging level
utils nested original class name value in the OpenCV API.
Create an owned utils_nested_OriginalClassName instance with the supplied configuration.
Return the original class name used by OpenCV's class-renaming binding regression helper.
utils nested original class name params value in the OpenCV API.
Run OpenCV's binding regression helper utils_nested_testEchoBooleanFunction. This diagnostic exercises argument conversion, overload selection or native exception propagation as in
Run OpenCV's binding regression helper utils_testAsyncArray. This diagnostic exercises argument conversion, overload selection or native exception propagation as indicated by its n
Run OpenCV's binding regression helper utils_testAsyncException. This diagnostic exercises argument conversion, overload selection or native exception propagation as indicated by i
Run OpenCV's binding regression helper utils_testOverloadResolution. This diagnostic exercises argument conversion, overload selection or native exception propagation as indicated
Run OpenCV's binding regression helper utils_testOverloadResolution1. This diagnostic exercises argument conversion, overload selection or native exception propagation as indicated
Run OpenCV's binding regression helper utils_testOverwriteNativeMethod. This diagnostic exercises argument conversion, overload selection or native exception propagation as indicat
Run OpenCV's binding regression helper utils_testRaiseGeneralException. This diagnostic exercises argument conversion, overload selection or native exception propagation as indicat
Run OpenCV's binding regression helper utils_testReservedKeywordConversion. This diagnostic exercises argument conversion, overload selection or native exception propagation as ind
Run OpenCV's binding regression helper utils_testRotatedRect. This diagnostic exercises argument conversion, overload selection or native exception propagation as indicated by its
Run OpenCV's binding regression helper utils_testRotatedRectVector. This diagnostic exercises argument conversion, overload selection or native exception propagation as indicated b
validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
JavaScript value constructors and OpenCV 5 matrix type constants/functions.
Type of variables used in LevMarq solver
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Variational optical flow refinement
Creates an instance of VariationalRefinement
```cpp
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
Fixed-size numeric components passed by value as a JavaScript tuple. No native disposal is required.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
videoio_flags_base
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
endcond: IGNORED
Wait for ready frames from VideoCapture.
cv::VideoCapture API backends identifier.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
Images
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
OBSENSOR stream generator
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
OBSENSOR properties
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
cv::VideoCapture generic properties identifier.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
An owned native vector. Append values with push_back, read them with get, and release the vector with using or delete(). Native object elements returned by get require separate dis
This section contains API description how to query/configure available Video I/O backends.
Returns list of all available backends
Returns description and ABI/API version of videoio plugin's camera interface
Named return value and scalar output parameters from videoio_registry_getCameraBackendPluginVersion. Matrix and vector output arguments are filled in place.
Returns list of available backends which works via `cv::VideoCapture(int index)`
Returns description and ABI/API version of videoio plugin's stream capture interface
Named return value and scalar output parameters from videoio_registry_getStreamBackendPluginVersion. Matrix and vector output arguments are filled in place.
Returns list of available backends which works via `cv::VideoCapture(filename)`
Returns description and ABI/API version of videoio plugin's buffer capture interface
Named return value and scalar output parameters from videoio_registry_getStreamBufferedBackendPluginVersion. Matrix and vector output arguments are filled in place.
Returns list of available backends which works via `cv::VideoCapture(buffer)`
Returns description and ABI/API version of videoio plugin's writer interface
Named return value and scalar output parameters from videoio_registry_getWriterBackendPluginVersion. Matrix and vector output arguments are filled in place.
Returns list of available backends which works via `cv::VideoWriter()`
Returns true if backend is available
Returns true if backend is built in (false if backend is used as plugin)
Describes motion model between two point clouds.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
example: samples/cpp/tutorial_code/videoio/video-write/video-write.cpp
Concatenates 4 chars to a fourcc code
cv::VideoWriter generic properties identifier.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Files used by native codecs, model readers and algorithms belong to this instance. Paths refer to its virtual filesystem, including in Node.
volume value in the OpenCV API.
Native enum entries for volume bounding box precision. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
volume settings value in the OpenCV API.
Native enum entries for volume type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Applies an affine transformation to an image.
Image warper factories base class.
Warps depth or RGB-D image by reprojecting it in 3d, applying Rt transformation
example: samples/cpp/snippets/warpPerspective_demo.cpp
Remaps an image to polar or semilog-polar coordinates space
Specify the polar mapping mode
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
imgproc_hist
WeChat QRCode includes two CNN-based models:
Write a .flo to disk
Class implementing affine adaptation for key points.
Wrapping class for feature detection using the AGAST method. :
Create an owned xfeatures2d_AgastFeatureDetector instance with the supplied configuration.
Class implementing the AKAZE keypoint detector and descriptor extractor, described in [ANB13].
The AKAZE constructor
Class implementing BEBLID (Boosted Efficient Binary Local Image Descriptor),
Descriptor number of bits, each bit is a boosting weak-learner.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Creates the BEBLID descriptor.
Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in
Create an owned xfeatures2d_BoostDesc instance with the supplied configuration.
Class to compute an image descriptor using the bag of visual words.
kmeans -based class to train visual vocabulary using the bag of visual words approach. :
\
BRIEF Descriptor
Create an owned xfeatures2d_BriefDescriptorExtractor instance with the supplied configuration.
Class implementing the BRISK keypoint detector and descriptor extractor, described in [LCS11] .
The BRISK constructor
The BRISK constructor for a custom pattern
The BRISK constructor for a custom pattern, detection threshold and octaves
Class implementing DAISY descriptor, described in [Tola10]
Create an owned xfeatures2d_DAISY instance with the supplied configuration.
Native enum entries for xfeatures2d daisy normalization type. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Class implementing the FREAK (Fast Retina Keypoint) keypoint descriptor, described in [AOV12] .
Create an owned xfeatures2d_FREAK instance with the supplied configuration.
Class implementing the Harris-Laplace feature detector as described in [Mikolajczyk2004].
Creates a new implementation instance.
Class implementing the KAZE keypoint detector and descriptor extractor, described in [ABD12] .
The KAZE constructor
LATCH Descriptor
Create an owned xfeatures2d_LATCH instance with the supplied configuration.
Class implementing the locally uniform comparison image descriptor, described in [LUCID]
Create an owned xfeatures2d_LUCID instance with the supplied configuration.
GMS (Grid-based Motion Statistics) feature matching strategy described in [Bian2017gms] .
LOGOS (Local geometric support for high-outlier spatial verification) feature matching strategy described in [Lowry2018LOGOSLG] .
Class implementing the MSD (Maximal Self-Dissimilarity) keypoint detector, described in [Tombari14].
Create an owned xfeatures2d_MSDDetector instance with the supplied configuration.
Position-Color-Texture signatures
Creates PCTSignatures algorithm using pre-generated sampling points
Creates PCTSignatures algorithm using pre-generated sampling points
Creates PCTSignatures algorithm using pre-generated sampling points
Lp distance function selector.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Draws signature in the source image and outputs the result.
Generates initial sampling points according to selected point distribution.
Point distributions supported by random point generator.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Similarity function selector.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Class implementing Signature Quadratic Form Distance (SQFD).
Creates the algorithm instance using selected distance function,
The class implements the keypoint detector introduced by [Agrawal08], synonym of StarDetector. :
the full constructor
Class for extracting Speeded Up Robust Features from an image [Bay06] .
Create an owned xfeatures2d_SURF instance with the supplied configuration.
Class implementing the Tree Based Morse Regions (TBMR) as described in
Create an owned xfeatures2d_TBMR instance with the supplied configuration.
Class implementing TEBLID (Triplet-based Efficient Binary Local Image Descriptor),
Creates the TEBLID descriptor.
Descriptor number of bits, each bit is a box average difference.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Class implementing VGG (Oxford Visual Geometry Group) descriptor trained end to end
Create an owned xfeatures2d_VGG instance with the supplied configuration.
Interface for Adaptive Manifold Filter realizations.
Create an owned ximgproc_AdaptiveManifoldFilter instance with the supplied configuration.
Simple one-line Adaptive Manifold Filter call.
Specifies the part of Hough space to calculate
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Performs anisotropic diffusion on an image.
Applies the bilateral texture filter to an image. It performs structure-preserving texture filter.
Compares a color template against overlapped color image regions.
Function for computing the percent of "bad" pixels in the disparity map
Function for computing mean square error for disparity maps
Class for ContourFitting algorithms.
Named return value and scalar output parameters from ximgproc_ContourFitting_estimateTransformation. Matrix and vector output arguments are filled in place.
Contour sampling .
Computes the estimated covariance matrix of an image using the sliding
Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines.
create ContourFitting algorithm object
Convenience factory method that creates an instance of DisparityWLSFilter and sets up all the relevant
More generic factory method, create instance of DisparityWLSFilter and execute basic
Factory method, create instance of DTFilter and produce initialization routines.
Factory method that creates an instance of the
Creates a Edgeboxes
Creates a smart pointer to a EdgeDrawing object and initializes it
Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.
Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.
Creates a smart pointer to a FastLineDetector object and initializes it
Factory method, create instance of GuidedFilter and produce initialization routines.
creates a quaternion image.
Create an owned ximgproc_RFFeatureGetter instance with the supplied configuration.
Factory method that creates an instance of the
Convenience method to set up the matcher for computing the right-view disparity map
Initializes a ScanSegment object.
The only constructor
Class implementing the LSC (Linear Spectral Clustering) superpixels
Initializes a SuperpixelSEEDS object.
Initialize a SuperpixelSLIC object
Main interface for all disparity map filters.
Disparity map filter based on Weighted Least Squares filter (in form of Fast Global Smoother that
Simple one-line Domain Transform filter call. If you have multiple images to filter with the same
Interface for realizations of Domain Transform filter.
Native enum entries for ximgproc edge aware filters list. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Sparse match interpolation algorithm based on modified locally-weighted affine
Class implementing EdgeBoxes algorithm from [ZitnickECCV14edgeBoxes] :
Class implementing the ED (EdgeDrawing) [topal2012edge], EDLines [akinlar2011edlines], EDPF [akinlar2012edpf], EDCircles [akinlar2013edcircles] and ColorED [akinlar201782] algorith
Native enum entries for ximgproc edge drawing gradient operator. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
ximgproc edge drawing params value in the OpenCV API.
Smoothes an image using the Edge-Preserving filter.
Simple one-line Fast Bilateral Solver filter call. If you have multiple images to filter with the same
Interface for implementations of Fast Bilateral Solver.
Simple one-line Fast Global Smoother filter call. If you have multiple images to filter with the same
Interface for implementations of Fast Global Smoother filter.
Calculates 2D Fast Hough transform of an image.
Class implementing the FLD (Fast Line Detector) algorithm described
Finds ellipses fastly in an image using projective invariant pruning.
Fourier descriptors for planed closed curves
Function for creating a disparity map visualization (clamped CV_8U image)
Applies X Deriche filter to an image.
Applies Y Deriche filter to an image.
Simple one-line (Fast) Guided Filter call.
Interface for realizations of (Fast) Guided Filter.
Specifies to do or not to do skewing of Hough transform image
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Specifies binary operations.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Calculates coordinates of line segment corresponded by point in Hough space.
Applies the joint bilateral filter to an image.
Global image smoothing via L0 gradient minimization.
Specifies the binarization method to use in cv::ximgproc::niBlackThreshold
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Performs thresholding on input images using Niblack's technique or some of the
Calculates an affine transformation that normalize given image using Pei&Lin Normalization.
calculates conjugate of a quaternion image.
Performs a forward or inverse Discrete quaternion Fourier transform of a 2D quaternion array.
Calculates the per-element quaternion product of two arrays
divides each element by its modulus.
Calculate Radon Transform of an image.
Function for reading ground truth disparity maps. Supports basic Middlebury
Helper class for training part of [P. Dollar and C. L. Zitnick. Structured Forests for Fast Edge Detection, 2013].
Sparse match interpolation algorithm based on modified piecewise locally-weighted affine
Applies Ridge Detection Filter to an input image.
Create pointer to the Ridge detection filter.
Applies the rolling guidance filter to an image.
Class implementing the F-DBSCAN (Accelerated superpixel image segmentation with a parallelized DBSCAN algorithm) superpixels
Creates a graph based segmentor
Create a new SelectiveSearchSegmentation class.
Create a new color-based strategy
Create a new fill-based strategy
Create a new multiple strategy
Create a new multiple strategy and set one subtrategy
Create a new multiple strategy and set two subtrategies, with equal weights
Create a new multiple strategy and set three subtrategies, with equal weights
Create a new multiple strategy and set four subtrategies, with equal weights
Create a new size-based strategy
Create a new size-based strategy
Graph Based Segmentation Algorithm.
Selective search segmentation algorithm
Strategie for the selective search segmentation algorithm
Color-based strategy for the selective search segmentation algorithm
Fill-based strategy for the selective search segmentation algorithm
Regroup multiple strategies for the selective search segmentation algorithm
Size-based strategy for the selective search segmentation algorithm
Texture-based strategy for the selective search segmentation algorithm
Native enum entries for ximgproc slictype. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Main interface for all filters, that take sparse matches as an
Class implementing edge detection algorithm from [Dollar2013] :
Class implementing the LSC (Linear Spectral Clustering) superpixels
Class implementing the SEEDS (Superpixels Extracted via Energy-Driven Sampling) superpixels
Class implementing the SLIC (Simple Linear Iterative Clustering) superpixels
Applies a binary blob thinning operation, to achieve a skeletization of the input image.
Native enum entries for ximgproc thinning types. Pass an entry to enum-typed arguments or its .value to numeric arguments.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
transform a contour
Applies weighted median filter to an image.
Specifies weight types of weighted median filter.
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Implements an efficient fixed-point approximation for applying channel gains, which is
Performs image denoising using the Block-Matching and 3D-filtering algorithm
Performs image denoising using the Block-Matching and 3D-filtering algorithm
BM3D algorithm steps
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
Creates an instance of GrayworldWB
Creates an instance of LearningBasedWB
Creates an instance of SimpleWB
Creates TonemapDurand object
The function implements simple dct-based denoising
Gray-world white balance algorithm
The function implements different single-image inpainting algorithms.
Various inpainting algorithms
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
More sophisticated learning-based automatic white balance algorithm.
oilPainting
oilPainting
A simple white balance algorithm that works by independently stretching
This algorithm decomposes image into two layers: base layer and detail layer using bilateral filter
BM3D transform types
A native enum entry wrapping its numeric .value. Flat OpenCV constants expose the corresponding numbers directly.
The base class for auto white balance algorithms.
No matches. Try an algorithm name, a module, or a shorter phrase.