Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

▼NOpenCVForUnity
►NArucoModule
CAruco
CEstimateParameters	Pose estimation parameters
►NBgsegmModule
CBackgroundSubtractorCNT	Background subtraction based on counting
CBackgroundSubtractorGMG	Background Subtractor module based on the algorithm given in [Gold2012]
CBackgroundSubtractorGSOC	Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper
CBackgroundSubtractorLSBP	Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at [LGuo2016]
CBackgroundSubtractorLSBPDesc	This is for calculation of the LSBP descriptors
CBackgroundSubtractorMOG	Gaussian Mixture-based Background/Foreground Segmentation Algorithm
CBgsegm
CSyntheticSequenceGenerator	Synthetic frame sequence generator for testing background subtraction algorithms
►NBioinspiredModule
CBioinspired
CRetina	Class which allows the Gipsa/Listic Labs model to be used with OpenCV
CRetinaFastToneMapping	Wrapper class which allows the tone mapping algorithm of Meylan&al(2007) to be used with OpenCV
CTransientAreasSegmentationModule	Class which provides a transient/moving areas segmentation module
►NCalib3dModule
CCalib3d
CStereoBM	Class for computing stereo correspondence using the block matching algorithm, introduced and contributed to OpenCV by K. Konolige
CStereoMatcher	The base class for stereo correspondence algorithms
CStereoSGBM	The class implements the modified H. Hirschmuller algorithm [HH08] that differs from the original one as follows:
CUsacParams
►NCoreModule
CAlgorithm	This is a base class for all more or less complex algorithms in OpenCV
►CCore
CMinMaxLocResult
CCvException	The exception that is thrown by OpenCVForUntiy
CCvType
CDMatch	Class for matching keypoint descriptors
CKeyPoint	Data structure for salient point detectors
CMat	N-dimensional dense array class
CMatOfByte	A specialized Mat class for storing single-channel byte data (CV_8UC1)
CMatOfDMatch	A specialized Mat class for storing DMatch objects with 32-bit floating-point attributes (CV_32FC4)
CMatOfDouble	A specialized Mat class for storing single-channel double-precision floating-point data (CV_64FC1)
CMatOfFloat	A specialized Mat class for storing single-channel floating-point data (CV_32FC1)
CMatOfFloat4	A specialized Mat class for storing 4-channel floating-point data (CV_32FC4)
CMatOfFloat6	A specialized Mat class for storing 6-channel floating-point data (CV_32FC6)
CMatOfInt	A specialized Mat class for storing single-channel integer data (CV_32SC1)
CMatOfInt4	A specialized Mat class for storing 4-channel integer data (CV_32SC4)
CMatOfKeyPoint	A specialized Mat class for storing keypoints with 32-bit floating-point attributes (CV_32FC7)
CMatOfPoint	A specialized Mat class for storing 2D points with 32-bit integer coordinates (CV_32SC2)
CMatOfPoint2f	A specialized Mat class for storing 2D points with floating-point coordinates (CV_32FC2)
CMatOfPoint3	A specialized Mat class for storing 3D points with 32-bit integer coordinates (CV_32SC3)
CMatOfPoint3f	A specialized Mat class for storing 3D points with 32-bit floating-point coordinates (CV_32FC3)
CMatOfRect	A specialized Mat class for storing rectangles with 32-bit integer coordinates (CV_32SC4)
CMatOfRect2d	A specialized Mat class for storing rectangles with 64-bit floating-point coordinates (CV_64FC4)
CMatOfRotatedRect	A specialized Mat class for storing rotated rectangles with 32-bit floating-point coordinates (CV_32FC5)
CPoint	Template class for 2D points specified by its coordinates x and y
CPoint3	Template class for 3D points specified by its coordinates x, y and z
CRange	Template class specifying a continuous subsequence (slice) of a sequence
CRect	Template class for 2D rectangles
CRect2d	Template class for 2D rectangles
CRotatedRect	The class represents rotated (i.e. not up-right) rectangles on a plane
CScalar	Template class for a 4-element vector derived from Vec
CSize	Template class for specifying the size of an image or rectangle
CTermCriteria	The class defining termination criteria for iterative algorithms
CTickMeter	Class to measure passing time
►NDnn_superresModule
CDnn_superres
CDnnSuperResImpl	A class to upscale images via convolutional neural networks. The following four models are implemented:
►NDnnModule
CClassificationModel	This class represents high-level API for classification models
CDetectionModel	This class represents high-level API for object detection networks
CDictValue	This struct stores the scalar value (or array) of one of the following type: double, cv::String or int64
CDnn
CImage2BlobParams	Processing params of image to blob
CKeypointsModel	This class represents high-level API for keypoints models
CLayer	This interface class allows to build new Layers - are building blocks of networks
CModel	This class is presented high-level API for neural networks
CNet	This class allows to create and manipulate comprehensive artificial neural networks
CSegmentationModel	This class represents high-level API for segmentation models
CTextDetectionModel	Base class for text detection networks
CTextDetectionModel_DB	This class represents high-level API for text detection DL networks compatible with DB model
CTextDetectionModel_EAST	This class represents high-level API for text detection DL networks compatible with EAST model
CTextRecognitionModel	This class represents high-level API for text recognition networks
►NFaceModule
CBasicFaceRecognizer
CBIF
CEigenFaceRecognizer
CFace
CFacemark	Abstract base class for all facemark models
CFacemarkAAM
CFacemarkKazemi
CFacemarkLBF
CFacemarkTrain	Abstract base class for trainable facemark models
CFaceRecognizer	Abstract base class for all face recognition models
CFisherFaceRecognizer
CLBPHFaceRecognizer
CMACE	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)
CPredictCollector	Abstract base class for all strategies of prediction result handling
CStandardCollector	Default predict collector
►NFeatures2dModule
CAffineFeature	Class for implementing the wrapper which makes detectors and extractors to be affine invariant, described as ASIFT in [YM11]
CAgastFeatureDetector	Wrapping class for feature detection using the AGAST method. :
CAKAZE	Class implementing the AKAZE keypoint detector and descriptor extractor, described in [ANB13]
CBFMatcher	Brute-force descriptor matcher
CBOWImgDescriptorExtractor	Class to compute an image descriptor using the bag of visual words
CBOWKMeansTrainer	Kmeans -based class to train visual vocabulary using the bag of visual words approach. :
CBOWTrainer	Abstract base class for training the bag of visual words vocabulary from a set of descriptors
CBRISK	Class implementing the BRISK keypoint detector and descriptor extractor, described in [LCS11]
CDescriptorMatcher	Abstract base class for matching keypoint descriptors
CFastFeatureDetector	Wrapping class for feature detection using the FAST method. :
CFeature2D	Abstract base class for 2D image feature detectors and descriptor extractors
CFeatures2d
CFlannBasedMatcher	Flann-based descriptor matcher
CGFTTDetector	Wrapping class for feature detection using the goodFeaturesToTrack function. :
CKAZE	Class implementing the KAZE keypoint detector and descriptor extractor, described in [ABD12]
CMSER	Maximally stable extremal region extractor
CORB	Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor
CSIFT	Class for extracting keypoints and computing descriptors using the Scale Invariant Feature Transform (SIFT) algorithm by D. Lowe [Lowe04]
CSimpleBlobDetector	Class for extracting blobs from an image. :
CSimpleBlobDetector_Params
►NImg_hashModule
CAverageHash	Computes average hash value of the input image
CBlockMeanHash	Image hash based on block mean
CColorMomentHash	Image hash based on color moments
CImg_hash
CImgHashBase	The base class for image hash algorithms
CMarrHildrethHash	Marr-Hildreth Operator Based Hash, slowest but more discriminative
CPHash	PHash
CRadialVarianceHash	Image hash based on Radon transform
►NImgcodecsModule
CImgcodecs
►NImgprocModule
CCLAHE	Base class for Contrast Limited Adaptive Histogram Equalization
CGeneralizedHough	Finds arbitrary template in the grayscale image using Generalized Hough Transform
CGeneralizedHoughBallard	Finds arbitrary template in the grayscale image using Generalized Hough Transform
CGeneralizedHoughGuil	Finds arbitrary template in the grayscale image using Generalized Hough Transform
CImgproc
CIntelligentScissorsMB	Intelligent Scissors image segmentation
CLineSegmentDetector	Line segment detector class
CMoments	Template class for moments
CSubdiv2D
►NMlModule
CANN_MLP	Artificial Neural Networks - Multi-Layer Perceptrons
CBoost	Boosted tree classifier derived from DTrees
CDTrees	The class represents a single decision tree or a collection of decision trees
CEM	The class implements the Expectation Maximization algorithm
CKNearest	The class implements K-Nearest Neighbors model
CLogisticRegression	Implements Logistic Regression classifier
CMl
CNormalBayesClassifier	Bayes classifier for normally distributed data
CParamGrid	The structure represents the logarithmic grid range of statmodel parameters
CRTrees	The class implements the random forest predictor
CStatModel	Base class for statistical models in OpenCV ML
CSVM	Support Vector Machines
CSVMSGD
CTrainData	Class encapsulating training data
►NObjdetectModule
CArucoDetector	The main functionality of ArucoDetector class is detection of markers in an image with detectMarkers() method
CBarcodeDetector
CBaseCascadeClassifier
CBoard	Board of ArUco markers
CCascadeClassifier	Cascade classifier class for object detection
CCharucoBoard	ChArUco board is a planar chessboard where the markers are placed inside the white squares of a chessboard
CCharucoDetector
CCharucoParameters
CDetectorParameters	Struct DetectorParameters is used by ArucoDetector
CDictionary	Dictionary is a set of unique ArUco markers of the same size
CFaceDetectorYN	DNN-based face detector
CFaceRecognizerSF	DNN-based face recognizer
CGraphicalCodeDetector
CGridBoard	Planar board with grid arrangement of markers
CHOGDescriptor	Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector
CObjdetect
CQRCodeDetector
CQRCodeDetectorAruco
CQRCodeDetectorAruco_Params
CQRCodeEncoder	Groups the object candidate rectangles. rectList Input/output vector of rectangles. Output vector includes retained and grouped rectangles. (The Python list is not modified in place.) weights Input/output vector of weights of rectangles. Output vector includes weights of retained and grouped rectangles. (The Python list is not modified in place.) groupThreshold Minimum possible number of rectangles minus 1. The threshold is used in a group of rectangles to retain it. eps Relative difference between sides of the rectangles to merge them into a group
CQRCodeEncoder_Params	QR code encoder parameters
CRefineParameters	Struct RefineParameters is used by ArucoDetector
►NPhase_unwrappingModule
CHistogramPhaseUnwrapping	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 16*pi*pi. 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
CHistogramPhaseUnwrapping_Params	Parameters of phaseUnwrapping constructor
CPhase_unwrapping
CPhaseUnwrapping	Abstract base class for phase unwrapping
►NPhotoModule
CAlignExposures	The base class for algorithms that align images of the same scene with different exposures
CAlignMTB	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
CCalibrateCRF	The base class for camera response calibration algorithms
CCalibrateDebevec	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
CCalibrateRobertson	Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system. This algorithm uses all image pixels
CMergeDebevec	The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response
CMergeExposures	The base class algorithms that can merge exposure sequence to a single image
CMergeMertens	Pixels are weighted using contrast, saturation and well-exposedness measures, than images are combined using laplacian pyramids
CMergeRobertson	The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response
CPhoto
CTonemap	Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range
CTonemapDrago	Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in logarithmic domain
CTonemapMantiuk	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
CTonemapReinhard	This is a global tonemapping operator that models human visual system
►NPlotModule
CPlot
CPlot2d
►NStructured_lightModule
CGrayCodePattern	Class implementing the Gray-code pattern, based on [UNDERWORLD]
CSinusoidalPattern	Class implementing Fourier transform profilometry (FTP) , phase-shifting profilometry (PSP) and Fourier-assisted phase-shifting profilometry (FAPS) based on [faps]
CSinusoidalPattern_Params	Parameters of SinusoidalPattern constructor width Projector's width. height Projector's height. nbrOfPeriods Number of period along the patterns direction. shiftValue Phase shift between two consecutive patterns. methodId Allow to choose between FTP, PSP and FAPS. nbrOfPixelsBetweenMarkers Number of pixels between two consecutive markers on the same row. setMarkers Allow to set markers on the patterns. markersLocation vector used to store markers location on the patterns
CStructured_light
CStructuredLightPattern	Abstract base class for generating and decoding structured light patterns
►NTextModule
CBaseOCR
CERFilter	Base class for 1st and 2nd stages of Neumann and Matas scene text detection algorithm [Neumann12]. :
CERFilter_Callback	Callback with the classifier is made a class
COCRBeamSearchDecoder	OCRBeamSearchDecoder class provides an interface for OCR using Beam Search algorithm
COCRBeamSearchDecoder_ClassifierCallback	Callback with the character classifier is made a class
COCRHMMDecoder	OCRHMMDecoder class provides an interface for OCR using Hidden Markov Models
COCRHMMDecoder_ClassifierCallback	Callback with the character classifier is made a class
CText
CTextDetector	An abstract class providing interface for text detection algorithms
CTextDetectorCNN	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
►NTrackingModule
Clegacy_MultiTracker	This class is used to track multiple objects using the specified tracker algorithm
Clegacy_Tracker	Base abstract class for the long-term tracker:
Clegacy_TrackerBoosting	Boosting tracker
Clegacy_TrackerCSRT	CSRT tracker
Clegacy_TrackerKCF	KCF (Kernelized Correlation Filter) tracker
Clegacy_TrackerMedianFlow	Median Flow tracker
Clegacy_TrackerMIL	The MIL algorithm trains a classifier in an online manner to separate the object from the background
Clegacy_TrackerMOSSE	MOSSE (Minimum Output Sum of Squared Error) tracker
Clegacy_TrackerTLD	TLD (Tracking, learning and detection) tracker
CTrackerCSRT	CSRT tracker
CTrackerCSRT_Params
CTrackerKCF	KCF (Kernelized Correlation Filter) tracker
CTrackerKCF_Params
CTracking
►NUnityUtils
►NHelper
CARHelper	A helper component for managing AR (Augmented Reality) functionalities
CAsyncGPUReadback2MatHelper	A helper component class for efficiently converting Unity Texture objects, such as RenderTexture and external texture format Texture2D, to OpenCV Mat format using AsyncGPUReadback
CFpsManager
CICameraSource2MatHelper
CIImageSource2MatHelper
CImage2MatHelper	A helper component class for loading an image file using OpenCV's Imgcodecs.imread method and converting it to an OpenCV Mat format
CImageOptimizationHelper	A helper component for optimizing image processing in Unity by managing frame skipping and downscaling operations. v1.1.1
CIMatUpdateFPSProvider
CISource2MatHelper
CITextureSource2MatHelper
CIVideoSource2MatHelper
CMultiSource2MatHelper	A versatile helper component class for obtaining frames as OpenCV Mat objects from multiple sources, allowing dynamic switching between different ISource2MatHelper classes
CSource2MatHelperErrorUnityEvent
CSource2MatHelperUtils
CUnityVideoPlayer2MatHelper	A helper component class for obtaining video frames from a file using Unity's VideoPlayer and converting them to OpenCV Mat format
CVideoCapture2MatHelper	A helper component class for obtaining video frames from a file using OpenCV's VideoCapture and converting them to OpenCV Mat format
CVideoCaptureCameraInputToMatHelper	VideoCaptureCameraInput to mat helper. v 1.0.1 Depends on OpenCVForUnity version 2.4.4 (WebCamTextureToMatHelper v 1.1.3) or later. (Use the WebCamDevice.isFrontFacing and WebCamTexture.videoRotationAngle properties to flip the camera input image in VideoCaptue to the correct orientation.)
►CVideoCaptureToMatHelper	VideoCapture to mat helper. v 1.0.4
CErrorUnityEvent
CWebCamTexture2MatAsyncGPUHelper	A helper component class for efficiently obtaining camera frames from WebCamTexture and converting them to OpenCV Mat format in real-time using AsyncGPUReadback
CWebCamTexture2MatHelper	A helper component class for obtaining camera frames from WebCamTexture and converting them to OpenCV Mat format in real-time
►CWebCamTextureToMatHelper	WebCamTexture to mat helper. v 1.1.6
CErrorUnityEvent
►NMOT
►NByteTrack
CBYTETracker	BYTETracker C# implementation of ByteTrack that does not include an object detection algorithm. The implementation is based on "ByteTrack-cpp". (https://github.com/derpda/ByteTrack-cpp/) Only tracking algorithm are implemented. Any object detection algorithm can be easily combined. Some code has been modified to obtain the same processing results as the original code below. https://github.com/ifzhang/ByteTrack/tree/main/deploy/ncnn/cpp https://github.com/ifzhang/ByteTrack/tree/main/yolox/tracker
CDetection
CIDetectionBase
CIRectBase
CKalmanFilter
CLapjv
CRectOperations
CTlwhRect
CTrack
CARUtils	AR utilities
CDebugMatUtils
CMatUtils
CPoseData
CUtils
CVec10d	10-Vector struct of double [CvType.CV_64FC10, Moments]
CVec2b	2-Vector struct of byte [CvType.CV_8UC2]
CVec2c	2-Vector struct of sbyte [CvType.CV_8SC2]
CVec2d	2-Vector struct of double [CvType.CV_64FC2, Point]
CVec2f	2-Vector struct of float [CvType.CV_32FC2]
CVec2i	2-Vector struct of int [CvType.CV_32SC2, Range]
CVec2s	2-Vector struct of short [CvType.CV_16SC2]
CVec2w	2-Vector struct of ushort [CvType.CV_16UC2, Size]
CVec3b	3-Vector struct of byte [CvType.CV_8UC3]
CVec3c	3-Vector struct of sbyte [CvType.CV_8SC3]
CVec3d	3-Vector struct of double [CvType.CV_64FC3, Point3]
CVec3f	3-Vector struct of float [CvType.CV_32FC3]
CVec3i	3-Vector struct of int [CvType.CV_32SC3]
CVec3s	3-Vector struct of short [CvType.CV_16SC3]
CVec3w	3-Vector struct of ushort [CvType.CV_16UC3]
CVec4b	4-Vector struct of byte [CvType.CV_8UC4]
CVec4c	4-Vector struct of sbyte [CvType.CV_8SC4]
CVec4d	4-Vector struct of double [CvType.CV_64FC4]
CVec4f	4-Vector struct of float [CvType.CV_32FC4, DMatch]
CVec4i	4-Vector struct of int [CvType.CV_32SC4, Rect]
CVec4s	4-Vector struct of short [CvType.CV_16SC4]
CVec4w	4-Vector struct of ushort [CvType.CV_16UC4, Rect2d, Scalar]
CVec5d	5-Vector struct of double [CvType.CV_64FC5, RotatedRect]
CVec5f	5-Vector struct of float [CvType.CV_32FC5, MatOfRotatedRect]
CVec6f	6-Vector struct of float [CvType.CV_32FC6, KeyPoint]
CVec7d	7-Vector struct of double [CvType.CV_32FC7]
CVec7f	7-Vector struct of float [CvType.CV_32FC7, KeyPoint]
►NUtilsModule
CConverters
►NVideoioModule
CVideoCapture	Class for video capturing from video files, image sequences or cameras
CVideoio
CVideoWriter	Video writer class
►NVideoModule
CBackgroundSubtractor	Base class for background/foreground segmentation. :
CBackgroundSubtractorKNN	K-nearest neighbours - based Background/Foreground Segmentation Algorithm
CBackgroundSubtractorMOG2	Gaussian Mixture-based Background/Foreground Segmentation Algorithm
CDenseOpticalFlow
CDISOpticalFlow	DIS optical flow algorithm
CFarnebackOpticalFlow	Class computing a dense optical flow using the Gunnar Farneback's algorithm
CKalmanFilter	Kalman filter class
CSparseOpticalFlow	Base interface for sparse optical flow algorithms
CSparsePyrLKOpticalFlow	Class used for calculating a sparse optical flow
CTracker	Base abstract class for the long-term tracker
CTrackerDaSiamRPN
CTrackerDaSiamRPN_Params
CTrackerGOTURN	GOTURN (Generic Object Tracking Using Regression Networks) tracker
CTrackerGOTURN_Params
CTrackerMIL	The MIL algorithm trains a classifier in an online manner to separate the object from the background
CTrackerMIL_Params
CTrackerNano	Nano tracker is a super lightweight dnn-based general object tracking
CTrackerNano_Params
CTrackerVit	VIT tracker is a super lightweight dnn-based general object tracking
CTrackerVit_Params
CVariationalRefinement	Variational optical flow refinement
CVideo
►NWechat_qrcodeModule
CWechat_qrcode
CWeChatQRCode	WeChat QRCode includes two CNN-based models: A object detection model and a super resolution model. Object detection model is applied to detect QRCode with the bounding box. super resolution model is applied to zoom in QRCode when it is small
►NXfeatures2dModule
CAffineFeature2D	Class implementing affine adaptation for key points
CBEBLID	Class implementing BEBLID (Boosted Efficient Binary Local Image Descriptor), described in [Suarez2020BEBLID]
CBoostDesc	Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in [Trzcinski13a] and [Trzcinski13b]
CBriefDescriptorExtractor	Class for computing BRIEF descriptors described in [calon2010]
CDAISY	Class implementing DAISY descriptor, described in [Tola10]
CFREAK	Class implementing the FREAK (Fast Retina Keypoint) keypoint descriptor, described in [AOV12]
CHarrisLaplaceFeatureDetector	Class implementing the Harris-Laplace feature detector as described in [Mikolajczyk2004]
CLATCH
CLUCID	Class implementing the locally uniform comparison image descriptor, described in [LUCID]
CMSDDetector	Class implementing the MSD (Maximal Self-Dissimilarity) keypoint detector, described in [Tombari14]
CPCTSignatures	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
CPCTSignaturesSQFD	Class implementing Signature Quadratic Form Distance (SQFD)
CStarDetector	The class implements the keypoint detector introduced by [Agrawal08], synonym of StarDetector. :
CTBMR	Class implementing the Tree Based Morse Regions (TBMR) as described in [Najman2014] extended with scaled extraction ability
CTEBLID	Class implementing TEBLID (Triplet-based Efficient Binary Local Image Descriptor), described in [Suarez2021TEBLID]
CVGG	Class implementing VGG (Oxford Visual Geometry Group) descriptor trained end to end using "Descriptor Learning Using Convex Optimisation" (DLCO) aparatus described in [Simonyan14]
CXfeatures2d
►NXimgprocModule
CAdaptiveManifoldFilter	Interface for Adaptive Manifold Filter realizations
CContourFitting	Class for ContourFitting algorithms. ContourFitting match two contours $\$z_a$$ and $\$z_b$$ minimizing distance
CDisparityFilter	Main interface for all disparity map filters
CDisparityWLSFilter	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
CDTFilter	Interface for realizations of Domain Transform filter
CEdgeAwareInterpolator	Sparse match interpolation algorithm based on modified locally-weighted affine estimator from [Revaud2015] and Fast Global Smoother as post-processing filter
CEdgeBoxes	Class implementing EdgeBoxes algorithm from [ZitnickECCV14edgeBoxes] :
CEdgeDrawing	Class implementing the ED (EdgeDrawing) [topal2012edge], EDLines [akinlar2011edlines], EDPF [akinlar2012edpf] and EDCircles [akinlar2013edcircles] algorithms
CEdgeDrawing_Params
CFastBilateralSolverFilter	Interface for implementations of Fast Bilateral Solver
CFastGlobalSmootherFilter	Interface for implementations of Fast Global Smoother filter
CFastLineDetector	Class implementing the FLD (Fast Line Detector) algorithm described in [Lee14]
CGraphSegmentation	Graph Based Segmentation Algorithm. The class implements the algorithm described in [PFF2004]
CGuidedFilter	Interface for realizations of (Fast) Guided Filter
CRFFeatureGetter
CRICInterpolator	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
CRidgeDetectionFilter	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]
CScanSegment	Class implementing the F-DBSCAN (Accelerated superpixel image segmentation with a parallelized DBSCAN algorithm) superpixels algorithm by Loke SC, et al. [loke2021accelerated] for original paper
CSelectiveSearchSegmentation	Selective search segmentation algorithm The class implements the algorithm described in [uijlings2013selective]
CSelectiveSearchSegmentationStrategy	Strategie for the selective search segmentation algorithm The class implements a generic stragery for the algorithm described in [uijlings2013selective]
CSelectiveSearchSegmentationStrategyColor	Color-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in [uijlings2013selective]
CSelectiveSearchSegmentationStrategyFill	Fill-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in [uijlings2013selective]
CSelectiveSearchSegmentationStrategyMultiple	Regroup multiple strategies for the selective search segmentation algorithm
CSelectiveSearchSegmentationStrategySize	Size-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in [uijlings2013selective]
CSelectiveSearchSegmentationStrategyTexture	Texture-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in [uijlings2013selective]
CSparseMatchInterpolator	Main interface for all filters, that take sparse matches as an input and produce a dense per-pixel matching (optical flow) as an output
CStructuredEdgeDetection	Class implementing edge detection algorithm from [Dollar2013] :
CSuperpixelLSC	Class implementing the LSC (Linear Spectral Clustering) superpixels algorithm described in [LiCVPR2015LSC]
CSuperpixelSEEDS	Class implementing the SEEDS (Superpixels Extracted via Energy-Driven Sampling) superpixels algorithm described in [VBRV14]
CSuperpixelSLIC	Class implementing the SLIC (Simple Linear Iterative Clustering) superpixels algorithm described in [Achanta2012]
CXimgproc
►NXphotoModule
CGrayworldWB	Gray-world white balance algorithm
CLearningBasedWB	More sophisticated learning-based automatic white balance algorithm
CSimpleWB	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 $\$p\mathrm{\%}$$ of pixel values
CTonemapDurand	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
CWhiteBalancer	The base class for auto white balance algorithms
CXphoto
CDisposableObject
CDisposableOpenCVObject
CApplicationException
CIComparable
CIDisposable
CIEquatable
CIStructuralComparable
CIStructuralEquatable
CMonoBehaviour