Class List

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

[detail level 12345678]

▼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
CCleanableMat
►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
CAnimation	Represents an animation with multiple frames. The Animation struct is designed to store and manage data for animated sequences such as those from animated formats (e.g., GIF, AVIF, APNG, WebP). It provides support for looping, background color settings, frame timing, and frame storage
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
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
►NSaliencyModule
CMotionSaliency
CMotionSaliencyBinWangApr2014	Fast Self-tuning Background Subtraction Algorithm from [BinWangApr2014]
CObjectness
CObjectnessBING	Binarized normed gradients algorithm from [BING]
CSaliency
CStaticSaliency
CStaticSaliencyFineGrained	Fine Grained Saliency approach from [FGS]
CStaticSaliencySpectralResidual	Spectral Residual approach from [SR]
►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
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
►NUnityIntegration
►NHelper
►NAR
CARCamera	A class that manages AR camera parameters and updates the projection matrix. This class utilizes camera calibration data to correct object positioning in AR space and provides functionalities for integrating with an OpenCV-based AR system
CARGameObject	Represents an augmented reality (AR) object that integrates with the ARCamera. This class manages solving Perspective-n-Point (PnP) problems, handling AR matrix transformations, and detecting whether the object is within the AR camera's viewport
CARHelper	The ARHelper class manages ARCamera and ARGameObjects, automating the calculation of ARMatrix and updating the Transform of the specified UpdateTarget
►NOptimization
CImageOptimizationHelper	A helper component for optimizing image processing in Unity by managing frame skipping and downscaling operations
►NSource2Mat
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	Interface to provide conversion from camera source to Mat
CIImageSource2MatHelper	Interface to provide conversion from image source to Mat
CImage2MatHelper	A helper component class for loading an image file using OpenCV's Imgcodecs.imread method and converting it to an OpenCV Mat format
CIMatTransformationProvider	Interface to define rotation and flip operations for image processing
CIMatUpdateFPSProvider	Interface to provide frame update rate functionality
CISource2MatHelper	Base interface for converting various sources to Mat
CITextureSource2MatHelper	Interface to provide conversion from texture source to Mat
CIVideoSource2MatHelper	Interface to provide conversion from video source to Mat
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
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
►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/Vertical-Beach/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
CBYTETrackInfo
CBYTETrackInfoVisualizer	BYTETrackInfoVisualizer A class that provides visualization functionality for BYTE tracking information
CBBox
CIMultiObjectTracker
CITrackInfoVisualizer
CTrackInfo
CTrackInfoVisualizer	TrackInfoVisualizer A class that provides visualization functionality for tracking information
CTrackInfoVisualizerBase	TrackInfoVisualizerBase A base class that provides common visualization functionality for tracking information
►NRunner
CMatSingleFlightSyncAsyncRunner	SingleFlightSyncAsyncRunner<TInput,TResult> specialized for OpenCV Mat inputs and outputs. The generic type parameters of the base are both Mat. Async input snapshots use copyTo into an internal buffer before asyncWork runs
CSingleFlightSyncAsyncRunner	Orchestrates at most one in-flight asynchronous Task versus synchronous syncWork, optional host cancellation, and a latest-result buffer for reference-type pipelines
CWorkCompletion	Payload for SingleFlightSyncAsyncRunner<TInput,TResult>.WorkCompleted
►NWorker
►NDataStruct
CClassificationData
CFaceDetection5LandmarkData
CObjectDetectionData
CPoseEstimationCOCO17Data
CPoseEstimationCOCO17DataUnsafe
►NDnnModule
►NMediaPipe
►NSkeletonVisualizer
CMediaPipeFaceSkeletonVisualizer	Visualizes a 3D face skeleton with LineRenderer from MediaPipeFaceLandmarker estimation results. Topology is based on MediaPipe FACEMESH_CONTOURS + FACEMESH_IRISES
CMediaPipeHandPoseSkeletonVisualizer	Visualizes a 3D hand skeleton with LineRenderer from MediaPipe hand pose estimation (world landmarks). Topology matches MediaPipeHandLandmarker HAND_LANDMARK_CONNECTIONS (21-landmark hand mesh)
CMediaPipePoseSkeletonVisualizer	Visualizes a 3D body pose skeleton with LineRenderer from MediaPipe pose estimation results. Topology follows the 33-keypoint BlazePose-style layout used by MediaPipePoseEstimator
►CMediaPipeSkeletonVisualizerBase	Base class for visualizing MediaPipe-style landmark estimation as a 3D skeleton using LineRenderer instances
CSkeleton	Holds one skeleton segment: a GameObject and its LineRenderer
►CMediaPipeFaceLandmarker	Processing worker that reproduces the face landmarking graph logic of MediaPipe FaceLandmarker on top of the OpenCV for Unity Dnn module
CFaceBlendshapeEstimationData	Packed result for one detected face blendshape output. The memory layout matches one row of the packed blendshape result matrix when output_face_blendshapes is enabled. Coefficients corresponds to the MediaPipe Task API face_blendshapes output represented as 52 coefficients
CFaceLandmarkerEstimationData	Packed result for one detected face. The memory layout matches one row produced by BuildPackedOutputMats. NormLandmarks corresponds to the MediaPipe Task API face_landmarks output represented as 478 Vec3f values. Face-level raw presence scores are not included; the internal threshold is configured by the MediaPipeFaceLandmarker constructor
CFacialTransformationMatrixEstimationData	Packed result for one detected facial transformation matrix. The memory layout matches one row of the packed facial transformation matrix result when output_facial_transformation_matrixes is enabled. RowMajor4x4 corresponds to the MediaPipe face geometry output stored as a row-major 4x4 matrix in the same ordering as MatrixData
►CMediaPipeHandLandmarker	Processing worker that reproduces the hand landmarking graph logic of MediaPipe HandLandmarker on top of the OpenCV for Unity Dnn module
CHandLandmarkerEstimationData	Packed result for one detected hand, without an explicit bounding box. The memory layout matches one row produced by PackResultsToMats. NormLandmarks corresponds to the MediaPipe Task API hand_landmarks output represented as 21 Vec3f values. WorldLandmarks corresponds to the MediaPipe Task API hand_world_landmarks output
CMediaPipeHolisticLandmarker	Processing worker that reproduces the holistic landmarking graph logic of MediaPipe HolisticLandmarker on top of the OpenCV for Unity Dnn module
►CMediaPipePoseLandmarker	Processing worker that reproduces the pose landmarking graph logic of MediaPipe PoseLandmarker on top of the OpenCV for Unity Dnn module
CPoseLandmarkerEstimationData	Packed result for one pose from Pose Landmarker. Memory-compatible with each row produced by PackResultsToMats. Order: 33 elements corresponding to the original NormalizedLandmark values (x, y, z, visibility, presence) followed by 33 elements corresponding to the original Landmark values with the same five components. The user-facing MediaPipe PoseLandmarker result does not expose a pose-level raw presence score, so this packed representation does not include it either; the threshold is applied inside the graph using the constructor's minPosePresenceConfidence
CDAMOYOLOObjectDetector	DAMO-YOLO object detector implementation. This class provides functionality for object detection using the DAMO-YOLO model implemented with OpenCV's DNN module. Referring to: https://github.com/tinyvision/DAMO-YOLO https://github.com/tinyvision/DAMO-YOLO/blob/master/tools/demo.py
CDnnInferenceWorkerBase	Base class for ProcessingWorkerBase derivatives that record DNN runtime options (DnnBackend / DnnTarget), support Unity Inference Engine (com.unity.ai.inference) as an alternative to OpenCV DNN, and share the same backend discriminator constants as MultiBackendDnn
►CFaceIdentificationEstimator	Face Identification Estimator with BYTETracker integration for robust face detection, tracking, and recognition in video streams
CFaceIdentificationData	Represents face detection and identification data with 5 facial landmarks and tracking information
CFacialExpressionRecognizer	Facial expression recognizer implementation. This class provides functionality for facial expression recognition using the Facial Expression Recognition model implemented with OpenCV's DNN module. Referring to https://github.com/opencv/opencv_zoo/tree/main/models/facial_expression_recognition
CMultiBackendDnn	Subset of OpenCV OpenCVForUnity.DnnModule.Dnn for loading models that may run on either OpenCV DNN or Sentis (com.unity.ai.inference)
CMultiBackendNet	Subset of OpenCV Net for inference with either OpenCV DNN or Sentis, with deferred initialization after MultiBackendDnn.readNet
CNanoDetPlusObjectDetector	NanoDetPlus object detector implementation. This class provides functionality for object detection using the NanoDetPlus model implemented with OpenCV's DNN module. Referring to: https://github.com/RangiLyu/nanodet https://github.com/RangiLyu/nanodet/blob/main/nanodet/model/head/nanodet_plus_head.py https://github.com/hpc203/nanodet-plus-opencv
CYOLOXObjectDetector	YOLOX object detector implementation. This class provides functionality for object detection using the YOLOX model implemented with OpenCV's DNN module. Referring to: https://github.com/opencv/opencv_zoo/tree/master/models/object_detection_yolox https://github.com/Megvii-BaseDetection/YOLOX https://github.com/Megvii-BaseDetection/YOLOX/tree/main/demo/ONNXRuntime
CYuNetV2FaceDetector	YuNetV2 face detector implementation. This class provides functionality for face detection using the YuNetV2 model implemented with OpenCV's DNN module. Referring to https://github.com/opencv/opencv_zoo/tree/main/models/face_detection_yunet
►NUtils
CClassLabelUtils	Utility class for handling class labels and names
CDnnProcessingUtils	Utility class for OpenCV DNN processing operations. Provides common functionality for DNN-based processing, including:
CMatPool	A pool for managing and reusing Mat objects to improve performance and reduce memory allocation. This pool is designed to handle Mat objects of a specific size and type
CIProcessingWorker
►CProcessingWorkerBase	Base class for processing workers that manage input and output Mats
CProcessingCompletion	Payload for ProcessingCompleted; same Kind / Error shape as WorkCompletion<TResult> without a results buffer (use PeekOutput / CopyOutput after success)
CDebugMat
►COpenCVARUtils	OpenCV AR utilities
CPoseData
COpenCVDebug	OpenCV Debug utilities
COpenCVEnv	OpenCV Environment utilities
COpenCVInternalUtils	OpenCV Internal utilities
COpenCVMatUtils	OpenCV Mat utilities
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
CIStreamReader	Read data stream interface
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], EDCircles [akinlar2013edcircles] and ColorED [akinlar201782] 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\%\)$ 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
CIAsyncDisposable
CIComparable
CIDisposable
CIEquatable
CIStructuralComparable
CIStructuralEquatable
CMonoBehaviour