Module opencv::hub_prelude

Traits

AKAZE	Class implementing the AKAZE keypoint detector and descriptor extractor, described in ANB13.
ANN_MLP	Artificial Neural Networks - Multi-Layer Perceptrons.
AbsLayer
AccumLayerTrait
ActivationLayer
AdaptiveManifoldFilter	Interface for Adaptive Manifold Filter realizations.
AffineFeature	Class for implementing the wrapper which makes detectors and extractors to be affine invariant, described as ASIFT in YM11 .
AffineFeature2D	Class implementing affine adaptation for key points.
AffineTransformer	Wrapper class for the OpenCV Affine Transformation algorithm. :
AffineWarperTrait	Affine warper factory class.
AgastFeatureDetector	Wrapping class for feature detection using the AGAST method. :
AlgorithmTrait	This is a base class for all more or less complex algorithms in OpenCV
AlignExposures	The base class for algorithms that align images of the same scene with different exposures
AlignMTB	This algorithm converts images to median threshold bitmaps (1 for pixels brighter than median luminance and 0 otherwise) and than aligns the resulting bitmaps using bit operations.
ArraysTrait	Wrapper for OpenGL Client-Side Vertex arrays.
AsyncArrayTrait	Returns result of asynchronous operations
AsyncPromiseTrait	Provides result of asynchronous operations
AutotunedIndexParamsTrait
AverageHashTrait	Computes average hash value of the input image
BEBLIDTrait	Class implementing BEBLID (Boosted Efficient Binary Local Image Descriptor), described in Suarez2020BEBLID .
BFMatcherTrait	Brute-force descriptor matcher.
BIF	Implementation of bio-inspired features (BIF) from the paper: Guo, Guodong, et al. "Human age estimation using bio-inspired features." Computer Vision and Pattern Recognition, 2009. CVPR 2009.
BNLLLayer
BOWImgDescriptorExtractorTrait	Class to compute an image descriptor using the bag of visual words.
BOWKMeansTrainerTrait	kmeans -based class to train visual vocabulary using the bag of visual words approach. :
BOWTrainer	Abstract base class for training the bag of visual words vocabulary from a set of descriptors.
BRISKTrait	Class implementing the BRISK keypoint detector and descriptor extractor, described in LCS11 .
BackendNodeTrait	Derivatives of this class encapsulates functions of certain backends.
BackendWrapper	Derivatives of this class wraps cv::Mat for different backends and targets.
BackgroundSubtractor	Base class for background/foreground segmentation. :
BackgroundSubtractorCNT	Background subtraction based on counting.
BackgroundSubtractorGMG	Background Subtractor module based on the algorithm given in Gold2012 .
BackgroundSubtractorGSOC	Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
BackgroundSubtractorKNN	K-nearest neighbours - based Background/Foreground Segmentation Algorithm.
BackgroundSubtractorLSBP	Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at LGuo2016
BackgroundSubtractorLSBPDescTrait	This is for calculation of the LSBP descriptors.
BackgroundSubtractorMOG	Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
BackgroundSubtractorMOG2	Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
BaseCascadeClassifier
BaseCascadeClassifier_MaskGenerator
BaseConvolutionLayerTrait
BaseOCR
BaseSFM	base class BaseSFM declares a common API that would be used in a typical scene reconstruction scenario
BasicFaceRecognizer
BatchNormLayer
BinaryDescriptorMatcherTrait	furnishes all functionalities for querying a dataset provided by user or internal to class (that user must, anyway, populate) on the model of @ref features2d_match
BinaryDescriptorTrait	Class implements both functionalities for detection of lines and computation of their binary descriptor.
BinaryDescriptor_ParamsTrait	List of BinaryDescriptor parameters:
BlankLayerTrait	Partial List of Implemented Layers
BlockMeanHashTrait	Image hash based on block mean.
BoardTrait	Board of markers
Boost	Boosted tree classifier derived from DTrees
BoostDesc	Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in Trzcinski13a and Trzcinski13b.
BriefDescriptorExtractorTrait	Class for computing BRIEF descriptors described in calon2010 .
BufferPoolTrait	BufferPool for use with CUDA streams
BufferTrait	Smart pointer for OpenGL buffer object with reference counting.
CLAHE	Base class for Contrast Limited Adaptive Histogram Equalization.
CParamsTrait
CUDA_BackgroundSubtractorMOG	Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
CUDA_BackgroundSubtractorMOG2	Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
CUDA_BroxOpticalFlow	Class computing the optical flow for two images using Brox et al Optical Flow algorithm (Brox2004).
CUDA_CLAHE	Base class for Contrast Limited Adaptive Histogram Equalization. :
CUDA_CannyEdgeDetector	Base class for Canny Edge Detector. :
CUDA_CornernessCriteria	Base class for Cornerness Criteria computation. :
CUDA_CornersDetector	Base class for Corners Detector. :
CUDA_DenseOpticalFlow	Base interface for dense optical flow algorithms.
CUDA_DensePyrLKOpticalFlow	Class used for calculating a dense optical flow.
CUDA_DescriptorMatcher	Abstract base class for matching keypoint descriptors.
CUDA_DisparityBilateralFilter	Class refining a disparity map using joint bilateral filtering. :
CUDA_FarnebackOpticalFlow	Class computing a dense optical flow using the Gunnar Farneback's algorithm.
CUDA_FastFeatureDetector	Wrapping class for feature detection using the FAST method.
CUDA_Feature2DAsync	Abstract base class for CUDA asynchronous 2D image feature detectors and descriptor extractors.
CUDA_HoughCirclesDetector	Base class for circles detector algorithm. :
CUDA_HoughLinesDetector	Base class for lines detector algorithm. :
CUDA_HoughSegmentDetector	Base class for line segments detector algorithm. :
CUDA_NvidiaHWOpticalFlow	Base Interface for optical flow algorithms using NVIDIA Optical Flow SDK.
CUDA_NvidiaOpticalFlow_1_0	Class for computing the optical flow vectors between two images using NVIDIA Optical Flow hardware and Optical Flow SDK 1.0.
CUDA_ORB	Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor
CUDA_OpticalFlowDual_TVL1	Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method.
CUDA_SparseOpticalFlow	Base interface for sparse optical flow algorithms.
CUDA_SparsePyrLKOpticalFlow	Class used for calculating a sparse optical flow.
CUDA_StereoBM	Class computing stereo correspondence (disparity map) using the block matching algorithm. :
CUDA_StereoBeliefPropagation	Class computing stereo correspondence using the belief propagation algorithm. :
CUDA_StereoConstantSpaceBP	Class computing stereo correspondence using the constant space belief propagation algorithm. :
CUDA_StereoSGM	The class implements the modified H. Hirschmuller algorithm HH08. Limitation and difference are as follows:
CUDA_TemplateMatching	Base class for Template Matching. :
CalibrateCRF	The base class for camera response calibration algorithms.
CalibrateDebevec	Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system. Objective function is constructed using pixel values on the same position in all images, extra term is added to make the result smoother.
CalibrateRobertson	Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system. This algorithm uses all image pixels.
CallMetaDataTrait	Optional information about a location in Code.
CameraTrait	This class wraps intrinsic parameters of a camera.
CascadeClassifier	Cascade classifier class used for object detection. Supports HAAR and LBP cascades. :
CascadeClassifierTrait	@example samples/cpp/facedetect.cpp This program demonstrates usage of the Cascade classifier class \image html Cascade_Classifier_Tutorial_Result_Haar.jpg "Sample screenshot" width=321 height=254
ChannelsPReLULayer
CharucoBoardTrait	ChArUco board Specific class for ChArUco boards. A ChArUco board is a planar board where the markers are placed inside the white squares of a chessboard. The benefits of ChArUco boards is that they provide both, ArUco markers versatility and chessboard corner precision, which is important for calibration and pose estimation. This class also allows the easy creation and drawing of ChArUco boards.
ChiHistogramCostExtractor	An Chi based cost extraction. :
ClassificationModelTrait	This class represents high-level API for classification models.
ColorAverageInpainterTrait
ColorCorrectionModelTrait	Core class of ccm model
ColorInpainterTrait
ColorMomentHashTrait	Image hash based on color moments.
ColorTrait	This class represents color in BGR order.
CommandLineParserTrait	Designed for command line parsing
CompositeIndexParamsTrait
CompressedRectilinearPortraitWarperTrait
CompressedRectilinearWarperTrait
ConcatLayerTrait
ConjGradSolver	This class is used to perform the non-linear non-constrained minimization of a function with known gradient,
ConsistentMosaicInpainterTrait
ConstLayerTrait	Constant layer produces the same data blob at an every forward pass.
ContextTrait
ContourFittingTrait	Class for ContourFitting algorithms. ContourFitting match two contours inline formula and inline formula minimizing distance block formula where inline formula and inline formula are Fourier descriptors of inline formula and inline formula and s is a scaling factor and inline formula is angle rotation and inline formula is starting point factor adjustement
Convolution	Base class for convolution (or cross-correlation) operator. :
ConvolutionLayerTrait
CorrelationLayerTrait
CropAndResizeLayerTrait
CropLayerTrait
CustomPatternTrait
CylindricalWarperTrait	Cylindrical warper factory class.
DAISY	Class implementing DAISY descriptor, described in Tola10
DFT	Base class for DFT operator as a cv::Algorithm. :
DISOpticalFlow	DIS optical flow algorithm.
DPMDetector	This is a C++ abstract class, it provides external user API to work with DPM.
DPMDetector_ObjectDetectionTrait
DTFilter	Interface for realizations of Domain Transform filter.
DTrees	The class represents a single decision tree or a collection of decision trees.
DTrees_NodeTrait	The class represents a decision tree node.
DTrees_SplitTrait	The class represents split in a decision tree.
DataAugmentationLayerTrait
DeblurerBase
DeconvolutionLayerTrait
DenseOpticalFlow	Base class for dense optical flow algorithms
DensePyrLkOptFlowEstimatorGpuTrait
DenseRLOFOpticalFlow	Fast dense optical flow computation based on robust local optical flow (RLOF) algorithms and sparse-to-dense interpolation scheme.
DepthCleanerTrait	Object that can clean a noisy depth image
DescriptorMatcher	Abstract base class for matching keypoint descriptors.
Detail_AffineBasedEstimatorTrait	Affine transformation based estimator.
Detail_AffineBestOf2NearestMatcherTrait	Features matcher similar to cv::detail::BestOf2NearestMatcher which finds two best matches for each feature and leaves the best one only if the ratio between descriptor distances is greater than the threshold match_conf.
Detail_AffineWarperTrait	Affine warper that uses rotations and translations
Detail_BestOf2NearestMatcherTrait	Features matcher which finds two best matches for each feature and leaves the best one only if the ratio between descriptor distances is greater than the threshold match_conf
Detail_BestOf2NearestRangeMatcherTrait
Detail_BlenderTrait	Base class for all blenders.
Detail_BlocksChannelsCompensatorTrait	Exposure compensator which tries to remove exposure related artifacts by adjusting image block on each channel.
Detail_BlocksCompensator	Exposure compensator which tries to remove exposure related artifacts by adjusting image blocks.
Detail_BlocksGainCompensatorTrait	Exposure compensator which tries to remove exposure related artifacts by adjusting image block intensities, see UES01 for details.
Detail_BundleAdjusterAffinePartialTrait	Bundle adjuster that expects affine transformation with 4 DOF represented in homogeneous coordinates in R for each camera param. Implements camera parameters refinement algorithm which minimizes sum of the reprojection error squares
Detail_BundleAdjusterAffineTrait	Bundle adjuster that expects affine transformation represented in homogeneous coordinates in R for each camera param. Implements camera parameters refinement algorithm which minimizes sum of the reprojection error squares
Detail_BundleAdjusterBase	Base class for all camera parameters refinement methods.
Detail_BundleAdjusterRayTrait	Implementation of the camera parameters refinement algorithm which minimizes sum of the distances between the rays passing through the camera center and a feature. :
Detail_BundleAdjusterReprojTrait	Implementation of the camera parameters refinement algorithm which minimizes sum of the reprojection error squares
Detail_CameraParamsTrait	Describes camera parameters.
Detail_ChannelsCompensatorTrait	Exposure compensator which tries to remove exposure related artifacts by adjusting image intensities on each channel independently.
Detail_CheckContextTrait
Detail_CompressedRectilinearPortraitProjectorTrait
Detail_CompressedRectilinearPortraitWarperTrait
Detail_CompressedRectilinearProjectorTrait
Detail_CompressedRectilinearWarperTrait
Detail_CylindricalPortraitProjectorTrait
Detail_CylindricalPortraitWarperTrait
Detail_CylindricalProjectorTrait
Detail_CylindricalWarperGpuTrait
Detail_CylindricalWarperTrait	Warper that maps an image onto the x*x + z*z = 1 cylinder.
Detail_DisjointSetsTrait
Detail_DpSeamFinderTrait
Detail_Estimator	Rotation estimator base class.
Detail_ExposureCompensator	Base class for all exposure compensators.
Detail_FeatherBlenderTrait	Simple blender which mixes images at its borders.
Detail_FeaturesMatcher	Feature matchers base class.
Detail_FisheyeProjectorTrait
Detail_FisheyeWarperTrait
Detail_GainCompensatorTrait	Exposure compensator which tries to remove exposure related artifacts by adjusting image intensities, see BL07 and WJ10 for details.
Detail_GraphCutSeamFinderBaseTrait	Base class for all minimum graph-cut-based seam estimators.
Detail_GraphCutSeamFinderGpuTrait
Detail_GraphCutSeamFinderTrait	Minimum graph cut-based seam estimator. See details in V03 .
Detail_GraphEdgeTrait
Detail_GraphTrait
Detail_HomographyBasedEstimatorTrait	Homography based rotation estimator.
Detail_ImageFeaturesTrait	Structure containing image keypoints and descriptors.
Detail_MatchesInfoTrait	Structure containing information about matches between two images.
Detail_MercatorProjectorTrait
Detail_MercatorWarperTrait
Detail_MultiBandBlenderTrait	Blender which uses multi-band blending algorithm (see BA83).
Detail_NoBundleAdjusterTrait	Stub bundle adjuster that does nothing.
Detail_NoExposureCompensatorTrait	Stub exposure compensator which does nothing.
Detail_NoSeamFinderTrait	Stub seam estimator which does nothing.
Detail_PairwiseSeamFinder	Base class for all pairwise seam estimators.
Detail_PaniniPortraitProjectorTrait
Detail_PaniniPortraitWarperTrait
Detail_PaniniProjectorTrait
Detail_PaniniWarperTrait
Detail_PlanePortraitProjectorTrait
Detail_PlanePortraitWarperTrait
Detail_PlaneProjectorTrait
Detail_PlaneWarperGpuTrait
Detail_PlaneWarperTrait	Warper that maps an image onto the z = 1 plane.
Detail_ProjectorBaseTrait	Base class for warping logic implementation.
Detail_RotationWarper	Rotation-only model image warper interface.
Detail_SeamFinder	Base class for a seam estimator.
Detail_SphericalPortraitProjectorTrait
Detail_SphericalPortraitWarperTrait
Detail_SphericalWarperGpuTrait
Detail_SphericalWarperTrait	Warper that maps an image onto the unit sphere located at the origin.
Detail_StereographicProjectorTrait
Detail_StereographicWarperTrait
Detail_TransverseMercatorProjectorTrait
Detail_TransverseMercatorWarperTrait
Detail_VoronoiSeamFinderTrait	Voronoi diagram-based seam estimator.
DetectionBasedTrackerTrait
DetectionBasedTracker_ExtObjectTrait
DetectionBasedTracker_IDetector
DetectionBasedTracker_ParametersTrait
DetectionModelTrait	This class represents high-level API for object detection networks.
DetectionOutputLayerTrait	Detection output layer.
DetectionROITrait	struct for detection region of interest (ROI)
DetectorParametersTrait	Parameters for the detectMarker process:
DeviceInfoTrait	Class providing functionality for querying the specified GPU properties.
DeviceTrait
DictTrait	This class implements name-value dictionary, values are instances of DictValue.
DictValueTrait	This struct stores the scalar value (or array) of one of the following type: double, cv::String or int64. @todo Maybe int64 is useless because double type exactly stores at least 2^52 integers.
DictionaryTrait	Dictionary/Set of markers. It contains the inner codification
DisparityFilter	Main interface for all disparity map filters.
DisparityWLSFilter	Disparity map filter based on Weighted Least Squares filter (in form of Fast Global Smoother that is a lot faster than traditional Weighted Least Squares filter implementations) and optional use of left-right-consistency-based confidence to refine the results in half-occlusions and uniform areas.
DnnSuperResImplTrait	A class to upscale images via convolutional neural networks. The following four models are implemented:
DownhillSolver	This class is used to perform the non-linear non-constrained minimization of a function,
DualTVL1OpticalFlow	"Dual TV L1" Optical Flow Algorithm.
Dynafu_DynaFu
ELULayer
EM	The class implements the Expectation Maximization algorithm.
EMDHistogramCostExtractor	An EMD based cost extraction. :
EMDL1HistogramCostExtractor	An EMD-L1 based cost extraction. :
ERFilter	Base class for 1st and 2nd stages of Neumann and Matas scene text detection algorithm Neumann12. :
ERFilter_Callback	Callback with the classifier is made a class.
ERStatTrait	The ERStat structure represents a class-specific Extremal Region (ER).
EdgeAwareInterpolator	Sparse match interpolation algorithm based on modified locally-weighted affine estimator from Revaud2015 and Fast Global Smoother as post-processing filter.
EdgeBoxes	Class implementing EdgeBoxes algorithm from ZitnickECCV14edgeBoxes :
EigenFaceRecognizer
Elliptic_KeyPointTrait	Elliptic region around an interest point.
EltwiseLayerTrait	Element wise operation on inputs
EncoderCallBack	Callbacks for CUDA video encoder.
EncoderParamsTrait	Different parameters for CUDA video encoder.
EventTrait
ExceptionTrait	! Class passed to an error.
FREAKTrait	Class implementing the FREAK (Fast Retina Keypoint) keypoint descriptor, described in AOV12 .
FaceRecognizer	Abstract base class for all face recognition models
Facemark	Abstract base class for all facemark models
FacemarkAAM
FacemarkAAM_ConfigTrait	\brief Optional parameter for fitting process.
FacemarkAAM_DataTrait	\brief Data container for the facemark::getData function
FacemarkAAM_ModelTrait	\brief The model of AAM Algorithm
FacemarkAAM_Model_TextureTrait
FacemarkAAM_ParamsTrait
FacemarkKazemi
FacemarkKazemi_ParamsTrait
FacemarkLBF
FacemarkLBF_ParamsTrait
FacemarkTrain	Abstract base class for trainable facemark models
FarnebackOpticalFlow	Class computing a dense optical flow using the Gunnar Farneback's algorithm.
FastBilateralSolverFilter	Interface for implementations of Fast Bilateral Solver.
FastFeatureDetector	Wrapping class for feature detection using the FAST method. :
FastGlobalSmootherFilter	Interface for implementations of Fast Global Smoother filter.
FastICPOdometryTrait	A faster version of ICPOdometry which is used in KinectFusion implementation Partial list of differences:
FastLineDetector	@include samples/fld_lines.cpp
FastMarchingMethodTrait	Describes the Fast Marching Method implementation.
Feature2DTrait
FileNodeIteratorTrait	used to iterate through sequences and mappings.
FileNodeTrait	File Storage Node class.
FileStorageTrait	XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or reading data to/from a file.
Filter	Common interface for all CUDA filters :
FisherFaceRecognizer
FisheyeWarperTrait
FlannBasedMatcherTrait	Flann-based descriptor matcher.
FlattenLayerTrait
FlowWarpLayerTrait
Formatted	@todo document
Formatter	@todo document
FreeType2
FromFileMotionReaderTrait
GFTTDetector	Wrapping class for feature detection using the goodFeaturesToTrack function. :
GPCDetailsTrait
GPCPatchDescriptorTrait
GPCPatchSampleTrait
GPCTrainingSamplesTrait	Class encapsulating training samples.
GPCTreeTrait	Class for individual tree.
GaussianMotionFilterTrait
GeneralizedHough	finds arbitrary template in the grayscale image using Generalized Hough Transform
GeneralizedHoughBallard	finds arbitrary template in the grayscale image using Generalized Hough Transform
GeneralizedHoughGuil	finds arbitrary template in the grayscale image using Generalized Hough Transform
GpuMatTrait	Base storage class for GPU memory with reference counting.
GpuMat_Allocator
GraphSegmentation	Graph Based Segmentation Algorithm. The class implements the algorithm described in PFF2004 .
GrayCodePattern	Class implementing the Gray-code pattern, based on UNDERWORLD.
GrayCodePattern_ParamsTrait	Parameters of StructuredLightPattern constructor.
GrayworldWB	Gray-world white balance algorithm
GridBoardTrait	Planar board with grid arrangement of markers More common type of board. All markers are placed in the same plane in a grid arrangement. The board can be drawn using drawPlanarBoard() function (see also: drawPlanarBoard)
GuidedFilter	Interface for realizations of Guided Filter.
HDF5	Hierarchical Data Format version 5 interface.
HOG	The class implements Histogram of Oriented Gradients (Dalal2005) object detector.
HOGDescriptorTrait	Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector.
HammingTrait
HarrisLaplaceFeatureDetectorTrait	Class implementing the Harris-Laplace feature detector as described in Mikolajczyk2004.
HausdorffDistanceExtractor
HfsSegment
HierarchicalClusteringIndexParamsTrait
HistogramCostExtractor	Abstract base class for histogram cost algorithms.
HistogramPhaseUnwrapping	Class implementing two-dimensional phase unwrapping based on histogramUnwrapping This algorithm belongs to the quality-guided phase unwrapping methods. First, it computes a reliability map from second differences between a pixel and its eight neighbours. Reliability values lie between 0 and 16pipi. Then, this reliability map is used to compute the reliabilities of "edges". An edge is an entity defined by two pixels that are connected horizontally or vertically. Its reliability is found by adding the the reliabilities of the two pixels connected through it. Edges are sorted in a histogram based on their reliability values. This histogram is then used to unwrap pixels, starting from the highest quality pixel.
HostMemTrait	Class with reference counting wrapping special memory type allocation functions from CUDA.
ICPOdometryTrait	Odometry based on the paper "KinectFusion: Real-Time Dense Surface Mapping and Tracking", Richard A. Newcombe, Andrew Fitzgibbon, at al, SIGGRAPH, 2011.
ICPTrait	This class implements a very efficient and robust variant of the iterative closest point (ICP) algorithm. The task is to register a 3D model (or point cloud) against a set of noisy target data. The variants are put together by myself after certain tests. The task is to be able to match partial, noisy point clouds in cluttered scenes, quickly. You will find that my emphasis is on the performance, while retaining the accuracy. This implementation is based on Tolga Birdal's MATLAB implementation in here: http://www.mathworks.com/matlabcentral/fileexchange/47152-icp-registration-using-efficient-variants-and-multi-resolution-scheme The main contributions come from:
IDenseOptFlowEstimator
IFrameSource
ILog
IMotionStabilizer
IOutlierRejector
ISparseOptFlowEstimator
Image2DTrait
ImageMotionEstimatorBase	Base class for global 2D motion estimation methods which take frames as input.
ImgHashBaseTrait	The base class for image hash algorithms
IndexParamsTrait
IndexTrait
InnerProductLayerTrait
InpainterBase
InpaintingPipelineTrait
InterpLayerTrait	Bilinear resize layer from https://github.com/cdmh/deeplab-public-ver2
KAZE	Class implementing the KAZE keypoint detector and descriptor extractor, described in ABD12 .
KDTreeIndexParamsTrait
KMeansIndexParamsTrait
KNearest	The class implements K-Nearest Neighbors model
KalmanFilterTrait	Kalman filter class.
KernelArgTrait
KernelTrait
KeyPointsFilterTrait	A class filters a vector of keypoints.
KeyboardEventTrait	This class represents a keyboard event.
KeypointBasedMotionEstimatorGpuTrait
KeypointBasedMotionEstimatorTrait	Describes a global 2D motion estimation method which uses keypoints detection and optical flow for matching.
KeypointsModelTrait	This class represents high-level API for keypoints models
Kinfu_KinFu	KinectFusion implementation
Kinfu_ParamsTrait
Kinfu_Volume
Kinfu_VolumeParamsTrait
LATCHTrait	latch Class for computing the LATCH descriptor. If you find this code useful, please add a reference to the following paper in your work: Gil Levi and Tal Hassner, "LATCH: Learned Arrangements of Three Patch Codes", arXiv preprint arXiv:1501.03719, 15 Jan. 2015
LBPHFaceRecognizer
LDATrait	Linear Discriminant Analysis @todo document this class
LMSolver	Levenberg-Marquardt solver. Starting with the specified vector of parameters it optimizes the target vector criteria "err" (finds local minima of each target vector component absolute value).
LMSolver_Callback
LRNLayerTrait
LSDDetectorTrait
LSTMLayer	LSTM recurrent layer
LUCIDTrait	Class implementing the locally uniform comparison image descriptor, described in LUCID
LargeKinfu	Large Scale Dense Depth Fusion implementation
LayerFactoryTrait	%Layer factory allows to create instances of registered layers.
LayerParamsTrait	This class provides all data needed to initialize layer.
LayerTrait	This interface class allows to build new Layers - are building blocks of networks.
LearningBasedWB	More sophisticated learning-based automatic white balance algorithm.
LineIteratorTrait	Line iterator
LineSegmentDetector	Line segment detector class
LinearIndexParamsTrait
Linemod_ColorGradientTrait	\brief Modality that computes quantized gradient orientations from a color image.
Linemod_DepthNormalTrait	\brief Modality that computes quantized surface normals from a dense depth map.
Linemod_DetectorTrait	\brief Object detector using the LINE template matching algorithm with any set of modalities.
Linemod_MatchTrait	\brief Represents a successful template match.
Linemod_Modality	\brief Interface for modalities that plug into the LINE template matching representation.
Linemod_QuantizedPyramid	\brief Represents a modality operating over an image pyramid.
Linemod_TemplateTrait
LogTagTrait
LogToStdoutTrait
LogisticRegression	Implements Logistic Regression classifier.
LookUpTable	Base class for transform using lookup table.
LpMotionStabilizerTrait
LshIndexParamsTrait
MACE	Minimum Average Correlation Energy Filter useful for authentication with (cancellable) biometrical features. (does not need many positives to train (10-50), and no negatives at all, also robust to noise/salting)
MCC_CChecker	CChecker
MCC_CCheckerDetector	A class to find the positions of the ColorCharts in the image.
MCC_CCheckerDraw	\brief checker draw
MCC_DetectorParametersTrait	Parameters for the detectMarker process:
MSDDetectorTrait	Class implementing the MSD (Maximal Self-Dissimilarity) keypoint detector, described in Tombari14.
MSER	Maximally stable extremal region extractor
MVNLayerTrait
MarrHildrethHashTrait	Marr-Hildreth Operator Based Hash, slowest but more discriminative.
MatConstIteratorTrait	/////////////////////////////// MatConstIterator //////////////////////////////////
MatExprTrait	Matrix expression representation @anchor MatrixExpressions This is a list of implemented matrix operations that can be combined in arbitrary complex expressions (here A, B stand for matrices ( Mat ), s for a scalar ( Scalar ), alpha for a real-valued scalar ( double )):
MatOp	////////////////////////////// Matrix Expressions /////////////////////////////////
MatSizeTrait
MatStepTrait
MatTrait	n-dimensional dense array class \anchor CVMat_Details
MatchTrait	\addtogroup stereo
Matx_AddOpTrait	@cond IGNORED
Matx_DivOpTrait
Matx_MatMulOpTrait
Matx_MulOpTrait
Matx_ScaleOpTrait
Matx_SubOpTrait
Matx_TOpTrait
MaxUnpoolLayerTrait
MercatorWarperTrait
MergeDebevec	The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response.
MergeExposures	The base class algorithms that can merge exposure sequence to a single image.
MergeMertens	Pixels are weighted using contrast, saturation and well-exposedness measures, than images are combined using laplacian pyramids.
MergeRobertson	The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response.
MeshTrait	This class wraps mesh attributes, and it can load a mesh from a ply file. :
MinProblemSolver	Basic interface for all solvers
MinProblemSolver_Function	Represents function being optimized
MishLayer
ModelTrait	This class is presented high-level API for neural networks.
MoreAccurateMotionWobbleSuppressorBase
MoreAccurateMotionWobbleSuppressorGpuTrait
MoreAccurateMotionWobbleSuppressorTrait
MotionEstimatorBase	Base class for all global motion estimation methods.
MotionEstimatorL1Trait	Describes a global 2D motion estimation method which minimizes L1 error.
MotionEstimatorRansacL2Trait	Describes a robust RANSAC-based global 2D motion estimation method which minimizes L2 error.
MotionFilterBase
MotionInpainterTrait
MotionSaliency	********************************* Motion Saliency Base Class ***********************************
MotionSaliencyBinWangApr2014Trait	!
MotionStabilizationPipelineTrait
MouseEventTrait	This class represents a mouse event.
MultiCameraCalibrationTrait	Class for multiple camera calibration that supports pinhole camera and omnidirection camera. For omnidirectional camera model, please refer to omnidir.hpp in ccalib module. It first calibrate each camera individually, then a bundle adjustment like optimization is applied to refine extrinsic parameters. So far, it only support "random" pattern for calibration, see randomPattern.hpp in ccalib module for details. Images that are used should be named by "cameraIdx-timestamp.*", several images with the same timestamp means that they are the same pattern that are photographed. cameraIdx should start from 0.
MultiCameraCalibration_edgeTrait
MultiCameraCalibration_vertexTrait
NetTrait	This class allows to create and manipulate comprehensive artificial neural networks.
NodeDataTrait
NormHistogramCostExtractor	A norm based cost extraction. :
NormalBayesClassifier	Bayes classifier for normally distributed data.
NormalizeBBoxLayerTrait	inline formula - normalization layer.
NullDeblurerTrait
NullFrameSourceTrait
NullInpainterTrait
NullLogTrait
NullOutlierRejectorTrait
NullWobbleSuppressorTrait
OCRBeamSearchDecoderTrait	OCRBeamSearchDecoder class provides an interface for OCR using Beam Search algorithm.
OCRBeamSearchDecoder_ClassifierCallbackTrait	Callback with the character classifier is made a class.
OCRHMMDecoderTrait	OCRHMMDecoder class provides an interface for OCR using Hidden Markov Models.
OCRHMMDecoder_ClassifierCallbackTrait	Callback with the character classifier is made a class.
OCRHolisticWordRecognizer	OCRHolisticWordRecognizer class provides the functionallity of segmented wordspotting. Given a predefined vocabulary , a DictNet is employed to select the most probable word given an input image.
OCRTesseract	OCRTesseract class provides an interface with the tesseract-ocr API (v3.02.02) in C++.
OLSTracker	implements "Optimal local searching for fast and robust textureless 3D object tracking in highly cluttered backgrounds" seo2013optimal
ORB	Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor
Objectness	********************************* Objectness Base Class ***********************************
ObjectnessBINGTrait	the Binarized normed gradients algorithm from BING
Odometry	Base class for computation of odometry.
OdometryFrameTrait	Object that contains a frame data that is possibly needed for the Odometry. It's used for the efficiency (to pass precomputed/cached data of the frame that participates in the Odometry processing several times).
OnePassStabilizerTrait
OpenCLExecutionContextTrait
OpticalFlowPCAFlowTrait	PCAFlow algorithm.
PCAPriorTrait	@brief This class can be used for imposing a learned prior on the resulting optical flow. Solution will be regularized according to this prior. You need to generate appropriate prior file with "learn_prior.py" script beforehand.
PCATrait	Principal Component Analysis
PCTSignatures	Class implementing PCT (position-color-texture) signature extraction as described in KrulisLS16. The algorithm is divided to a feature sampler and a clusterizer. Feature sampler produces samples at given set of coordinates. Clusterizer then produces clusters of these samples using k-means algorithm. Resulting set of clusters is the signature of the input image.
PCTSignaturesSQFD	Class implementing Signature Quadratic Form Distance (SQFD).
PHashTrait	pHash
PPF3DDetectorTrait	Class, allowing the load and matching 3D models. Typical Use:
PaddingLayerTrait	Adds extra values for specific axes.
PaniniPortraitWarperTrait
PaniniWarperTrait
ParallelLoopBody	Base class for parallel data processors
ParamGridTrait	The structure represents the logarithmic grid range of statmodel parameters.
ParamsTrait
PermuteLayerTrait
PhaseUnwrapping	Abstract base class for phase unwrapping.
PlaneWarperTrait	Plane warper factory class.
PlatformInfoTrait
PlatformTrait	@deprecated
Plot2d
PoolingLayerTrait
Pose3DTrait	Class, allowing the storage of a pose. The data structure stores both the quaternions and the matrix forms. It supports IO functionality together with various helper methods to work with poses
PoseCluster3DTrait	When multiple poses (see Pose3D) are grouped together (contribute to the same transformation) pose clusters occur. This class is a general container for such groups of poses. It is possible to store, load and perform IO on these poses.
PowerLayer
PredictCollector	Abstract base class for all strategies of prediction result handling
PriorBoxLayerTrait
ProgramSourceTrait
ProgramTrait
PropagationParametersTrait
ProposalLayerTrait
PyRotationWarperTrait
PyrLkOptFlowEstimatorBaseTrait
QRCodeDetectorTrait
QtFontTrait	QtFont available only for Qt. See cv::fontQt
QualityBRISQUETrait	BRISQUE (Blind/Referenceless Image Spatial Quality Evaluator) is a No Reference Image Quality Assessment (NR-IQA) algorithm.
QualityBase	********************************* Quality Base Class ***********************************
QualityGMSDTrait	Full reference GMSD algorithm http://www4.comp.polyu.edu.hk/~cslzhang/IQA/GMSD/GMSD.htm
QualityMSETrait	Full reference mean square error algorithm https://en.wikipedia.org/wiki/Mean_squared_error
QualityPSNRTrait	Full reference peak signal to noise ratio (PSNR) algorithm https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
QualitySSIMTrait	Full reference structural similarity algorithm https://en.wikipedia.org/wiki/Structural_similarity
QuasiDenseStereo	Class containing the methods needed for Quasi Dense Stereo computation.
QueueTrait
RFFeatureGetter	! Helper class for training part of [P. Dollar and C. L. Zitnick. Structured Forests for Fast Edge Detection, 2013].
RICInterpolator	Sparse match interpolation algorithm based on modified piecewise locally-weighted affine estimator called Robust Interpolation method of Correspondences or RIC from Hu2017 and Variational and Fast Global Smoother as post-processing filter. The RICInterpolator is a extension of the EdgeAwareInterpolator. Main concept of this extension is an piece-wise affine model based on over-segmentation via SLIC superpixel estimation. The method contains an efficient propagation mechanism to estimate among the pieces-wise models.
RLOFOpticalFlowParameterTrait	This is used store and set up the parameters of the robust local optical flow (RLOF) algoritm.
RNGTrait	Random Number Generator
RNG_MT19937Trait	Mersenne Twister random number generator
RNNLayer	Classical recurrent layer
RTrees	The class implements the random forest predictor.
RadialVarianceHashTrait	Image hash based on Radon transform.
RandomPatternCornerFinderTrait	Class for finding features points and corresponding 3D in world coordinate of a "random" pattern, which can be to be used in calibration. It is useful when pattern is partly occluded or only a part of pattern can be observed in multiple cameras calibration. The pattern can be generated by RandomPatternGenerator class described in this file.
RandomPatternGeneratorTrait
RangeTrait	Template class specifying a continuous subsequence (slice) of a sequence.
RansacParamsTrait	Describes RANSAC method parameters.
Rapid	wrapper around @ref rapid function for uniform access
RawVideoSource	Interface for video demultiplexing. :
ReLU6Layer
ReLULayer
RegionLayerTrait
ReorgLayerTrait
ReshapeLayerTrait
ResizeLayerTrait	Resize input 4-dimensional blob by nearest neighbor or bilinear strategy.
Retina	class which allows the Gipsa/Listic Labs model to be used with OpenCV.
RetinaFastToneMapping	a wrapper class which allows the tone mapping algorithm of Meylan&al(2007) to be used with OpenCV.
RetinaParametersTrait	retina model parameters structure
RgbdFrameTrait	Object that contains a frame data.
RgbdICPOdometryTrait	Odometry that merges RgbdOdometry and ICPOdometry by minimize sum of their energy functions.
RgbdNormalsTrait	Object that can compute the normals in an image. It is an object as it can cache data for speed efficiency The implemented methods are either:
RgbdOdometryTrait	Odometry based on the paper "Real-Time Visual Odometry from Dense RGB-D Images", F. Steinbucker, J. Strum, D. Cremers, ICCV, 2011.
RgbdPlaneTrait	Object that can compute planes in an image
RidgeDetectionFilter	Applies Ridge Detection Filter to an input image. Implements Ridge detection similar to the one in Mathematica using the eigen values from the Hessian Matrix of the input image using Sobel Derivatives. Additional refinement can be done using Skeletonization and Binarization. Adapted from segleafvein and M_RF
RotatedRectTrait	The class represents rotated (i.e. not up-right) rectangles on a plane.
SFMLibmvEuclideanReconstruction	SFMLibmvEuclideanReconstruction class provides an interface with the Libmv Structure From Motion pipeline.
SIFTTrait	Class for extracting keypoints and computing descriptors using the Scale Invariant Feature Transform (SIFT) algorithm by D. Lowe Lowe04 .
SURF	Class for extracting Speeded Up Robust Features from an image Bay06 .
SURF_CUDATrait	Class used for extracting Speeded Up Robust Features (SURF) from an image. :
SVDTrait	Singular Value Decomposition
SVM	Support Vector Machines.
SVMSGD	! Stochastic Gradient Descent SVM classifier
SVM_Kernel
Saliency	********************************* Saliency Base Class ***********************************
SavedIndexParamsTrait
ScaleLayerTrait
SearchParamsTrait
SegmentationModelTrait	This class represents high-level API for segmentation models
SelectiveSearchSegmentation	Selective search segmentation algorithm The class implements the algorithm described in uijlings2013selective.
SelectiveSearchSegmentationStrategy	Strategie for the selective search segmentation algorithm The class implements a generic stragery for the algorithm described in uijlings2013selective.
SelectiveSearchSegmentationStrategyColor	Color-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in uijlings2013selective.
SelectiveSearchSegmentationStrategyFill	Fill-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in uijlings2013selective.
SelectiveSearchSegmentationStrategyMultiple	Regroup multiple strategies for the selective search segmentation algorithm
SelectiveSearchSegmentationStrategySize	Size-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in uijlings2013selective.
SelectiveSearchSegmentationStrategyTexture	Texture-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in uijlings2013selective.
ShapeContextDistanceExtractor
ShapeDistanceExtractor	@example modules/shape/samples/shape_example.cpp An example using shape distance algorithm
ShapeTransformer	Abstract base class for shape transformation algorithms.
ShiftLayerTrait
ShuffleChannelLayerTrait	Permute channels of 4-dimensional input blob.
SigmoidLayer
SimilarRectsTrait	class for grouping object candidates, detected by Cascade Classifier, HOG etc. instance of the class is to be passed to cv::partition (see cxoperations.hpp)
SimpleBlobDetectorTrait	Class for extracting blobs from an image. :
SimpleWB	A simple white balance algorithm that works by independently stretching each of the input image channels to the specified range. For increased robustness it ignores the top and bottom inline formula of pixel values.
SinusoidalPattern	Class implementing Fourier transform profilometry (FTP) , phase-shifting profilometry (PSP) and Fourier-assisted phase-shifting profilometry (FAPS) based on faps.
SinusoidalPattern_ParamsTrait	Parameters of SinusoidalPattern constructor
SliceLayerTrait	Slice layer has several modes:
SoftmaxLayerTrait
SparseMatConstIteratorTrait	Read-Only Sparse Matrix Iterator.
SparseMatIteratorTrait	Read-write Sparse Matrix Iterator
SparseMatTrait	The class SparseMat represents multi-dimensional sparse numerical arrays.
SparseMat_HdrTrait	the sparse matrix header
SparseMat_NodeTrait	sparse matrix node - element of a hash table
SparseMatchInterpolator	Main interface for all filters, that take sparse matches as an input and produce a dense per-pixel matching (optical flow) as an output.
SparseOpticalFlow	Base interface for sparse optical flow algorithms.
SparsePyrLKOpticalFlow	Class used for calculating a sparse optical flow.
SparsePyrLkOptFlowEstimatorGpuTrait
SparsePyrLkOptFlowEstimatorTrait
SparseRLOFOpticalFlow	Class used for calculation sparse optical flow and feature tracking with robust local optical flow (RLOF) algorithms.
SphericalWarperTrait	Spherical warper factory class
SplitLayerTrait
StabilizerBase
StandardCollectorTrait	Default predict collector
StarDetectorTrait	The class implements the keypoint detector introduced by Agrawal08, synonym of StarDetector. :
StatModel	Base class for statistical models in OpenCV ML.
StaticSaliency	********************************* Static Saliency Base Class ***********************************
StaticSaliencyFineGrainedTrait	the Fine Grained Saliency approach from FGS
StaticSaliencySpectralResidualTrait	the Spectral Residual approach from SR
StereoBM	Class for computing stereo correspondence using the block matching algorithm, introduced and contributed to OpenCV by K. Konolige.
StereoMatcher	The base class for stereo correspondence algorithms.
StereoSGBM	The class implements the modified H. Hirschmuller algorithm HH08 that differs from the original one as follows:
StereographicWarperTrait
StitcherTrait	High level image stitcher.
StreamTrait	This class encapsulates a queue of asynchronous calls.
StructuredEdgeDetection	Class implementing edge detection algorithm from Dollar2013 :
StructuredLightPattern	Abstract base class for generating and decoding structured light patterns.
Subdiv2DTrait
SuperpixelLSC	Class implementing the LSC (Linear Spectral Clustering) superpixels algorithm described in LiCVPR2015LSC.
SuperpixelSEEDS	Class implementing the SEEDS (Superpixels Extracted via Energy-Driven Sampling) superpixels algorithm described in VBRV14 .
SuperpixelSLIC	Class implementing the SLIC (Simple Linear Iterative Clustering) superpixels algorithm described in Achanta2012.
Superres_BroxOpticalFlow
Superres_DenseOpticalFlowExt
Superres_DualTVL1OpticalFlow
Superres_FarnebackOpticalFlow
Superres_FrameSource
Superres_PyrLKOpticalFlow
Superres_SuperResolution	Base class for Super Resolution algorithms.
SwishLayer
SyntheticSequenceGeneratorTrait	Synthetic frame sequence generator for testing background subtraction algorithms.
TBMR	Class implementing the Tree Based Morse Regions (TBMR) as described in Najman2014 extended with scaled extraction ability.
TLSDataContainer	TLS container base implementation
TanHLayer
TargetArchsTrait	Class providing a set of static methods to check what NVIDIA* card architecture the CUDA module was built for.
TextDetectionModelTrait	Base class for text detection networks
TextDetectionModel_DBTrait	This class represents high-level API for text detection DL networks compatible with DB model.
TextDetectionModel_EASTTrait	This class represents high-level API for text detection DL networks compatible with EAST model.
TextDetector	An abstract class providing interface for text detection algorithms
TextDetectorCNN	TextDetectorCNN class provides the functionallity of text bounding box detection. This class is representing to find bounding boxes of text words given an input image. This class uses OpenCV dnn module to load pre-trained model described in LiaoSBWL17. The original repository with the modified SSD Caffe version: https://github.com/MhLiao/TextBoxes. Model can be downloaded from DropBox. Modified .prototxt file with the model description can be found in opencv_contrib/modules/text/samples/textbox.prototxt.
TextRecognitionModelTrait	This class represents high-level API for text recognition networks.
Texture2DTrait	Smart pointer for OpenGL 2D texture memory with reference counting.
ThinPlateSplineShapeTransformer	Definition of the transformation
TickMeterTrait	a Class to measure passing time.
TimerTrait
ToFileMotionWriterTrait
Tonemap	Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range.
TonemapDrago	Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in logarithmic domain.
TonemapDurand	This algorithm decomposes image into two layers: base layer and detail layer using bilateral filter and compresses contrast of the base layer thus preserving all the details.
TonemapMantiuk	This algorithm transforms image to contrast using gradients on all levels of gaussian pyramid, transforms contrast values to HVS response and scales the response. After this the image is reconstructed from new contrast values.
TonemapReinhard	This is a global tonemapping operator that models human visual system.
Tracker	Abstract base class for stateful silhouette trackers
Tracker	Base abstract class for the long-term tracker
TrackerCSRT	the CSRT tracker
TrackerCSRT_ParamsTrait
TrackerGOTURN	the GOTURN (Generic Object Tracking Using Regression Networks) tracker
TrackerGOTURN_ParamsTrait
TrackerKCF	the KCF (Kernelized Correlation Filter) tracker
TrackerMIL	The MIL algorithm trains a classifier in an online manner to separate the object from the background.
TrainData	Class encapsulating training data.
TransientAreasSegmentationModule	class which provides a transient/moving areas segmentation module
TranslationBasedLocalOutlierRejectorTrait
TransverseMercatorWarperTrait
TwoPassStabilizerTrait
UMatDataTrait
UMatTrait	@todo document
VGG	Class implementing VGG (Oxford Visual Geometry Group) descriptor trained end to end using "Descriptor Learning Using Convex Optimisation" (DLCO) aparatus described in Simonyan14.
VariationalRefinement	Variational optical flow refinement
VideoCaptureTrait	Class for video capturing from video files, image sequences or cameras.
VideoFileSourceTrait
VideoReader	Video reader interface.
VideoWriter	Video writer interface.
VideoWriterTrait	Video writer class.
Viz3dTrait	The Viz3d class represents a 3D visualizer window. This class is implicitly shared.
WArrowTrait	This 3D Widget defines an arrow.
WBDetector	WaldBoost detector
WCameraPositionTrait	This 3D Widget represents camera position in a scene by its axes or viewing frustum. :
WCircleTrait	This 3D Widget defines a circle.
WCloudCollectionTrait	This 3D Widget defines a collection of clouds. :
WCloudNormalsTrait	This 3D Widget represents normals of a point cloud. :
WCloudTrait	This 3D Widget defines a point cloud. :
WConeTrait	This 3D Widget defines a cone. :
WCoordinateSystemTrait	This 3D Widget represents a coordinate system. :
WCubeTrait	This 3D Widget defines a cube.
WCylinderTrait	This 3D Widget defines a cylinder. :
WGridTrait	This 3D Widget defines a grid. :
WImage3DTrait	This 3D Widget represents an image in 3D space. :
WImageOverlayTrait	This 2D Widget represents an image overlay. :
WLineTrait	This 3D Widget defines a finite line.
WMeshTrait	Constructs a WMesh.
WPaintedCloudTrait
WPlaneTrait	This 3D Widget defines a finite plane.
WPolyLineTrait	This 3D Widget defines a poly line. :
WSphereTrait	This 3D Widget defines a sphere. :
WText3DTrait	This 3D Widget represents 3D text. The text always faces the camera.
WTextTrait	This 2D Widget represents text overlay.
WTrajectoryFrustumsTrait	This 3D Widget represents a trajectory. :
WTrajectorySpheresTrait	This 3D Widget represents a trajectory using spheres and lines
WTrajectoryTrait	This 3D Widget represents a trajectory. :
WWidgetMergerTrait	This class allows to merge several widgets to single one.
WarperCreator	Image warper factories base class.
WeightingDeblurerTrait
WhiteBalancer	The base class for auto white balance algorithms.
Widget2DTrait	Base class of all 2D widgets.
Widget3DTrait	Base class of all 3D widgets.
WidgetTrait	Base class of all widgets. Widget is implicitly shared.
WindowScene	A 3D viewport and the associated scene
WobbleSuppressorBase
WriteStructContextTrait
_InputArrayTrait	This is the proxy class for passing read-only input arrays into OpenCV functions.
_InputOutputArrayTrait
_OutputArrayTrait	This type is very similar to InputArray except that it is used for input/output and output function parameters.
_RangeTrait