Class List

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

[detail level 12345678]

▼NOpenCVForUnity
►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
►NCalibModule
CCalib
►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
CTokenizer	High-level tokenizer wrapper for DNN usage
►NExtensions
►NAR
►CARPoseEstimator	Engine-independent AR pose estimation pipeline (solvePnP, NDC viewport, pose filtering). Engine integration layers copy runtime settings into ARPoseEstimateSettings and apply the returned PoseData via OpenCVARUtils.ConvertPoseDataToMat4 (or equivalent host transforms)
CARPoseEstimateResult	Result of a single Estimate call
CARPoseEstimateSettings	Per-frame pose estimation settings used by ARPoseEstimator.Estimate
CNdcAxisRange	Valid NDC axis interval (min/max)
►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	Track information returned by BYTETracker
CBYTETrackInfoVisualizer	BYTETrackInfoVisualizer A class that provides visualization functionality for BYTE tracking information
CBBox	Bounding box data for multi-object tracking
CIMultiObjectTracker	Multi-object tracker interface
CITrackInfoVisualizer	Track information visualizer interface
CTrackInfo	Basic track information containing a bounding box and track identifier
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
►NSourceToMat
►NDerivedFrame
CDerivedFrameCollection	Manages named DerivedFrameProcessor instances and drives them each tick
CDerivedFrameContext	Read-only per-tick metadata passed to derived frame processors. Input OpenCVForUnity.CoreModule.Mat data is supplied separately to IDerivedFrameProcessor.Apply
CDerivedFrameCoordinateUtils	Coordinate restoration helpers for detections computed on a scaled derived frame
CDerivedFrameProcessor	Default implementation of IDerivedFrameProcessor for a single named derived frame
CDerivedFrameSettings	Configuration for a single derived frame (spatial scale, color, and frame/tick rate control)
CFrameMatLayoutSignature	Immutable layout identity for a OpenCVForUnity.CoreModule.Mat frame buffer (columns, rows, OpenCV type)
CIDerivedFrame	Read-only view of a derived frame's published buffer and layout metadata. Configuration lives on IDerivedFrameProcessor; obtain it via DerivedFrameCollection.GetProcessor(string)
CIDerivedFrameProcessor	Processes the source layer Mat into a named derived frame with optional thinning. Extends IDerivedFrame so the same instance exposes both configuration and the published output view
►NGrabbers
CIFrameGrabber	Pull-based frame acquisition from a concrete media backend
CIFrameGrabberLayoutFrame	Optional capability for IFrameGrabber implementations that can expose the current held frame for output layout changes without advancing playback
CIFrameGrabberOpenState	Optional capability for IFrameGrabber implementations that expose open state
CImageFileFrameGrabber	OpenCV Imgcodecs.imread-based IFrameGrabber for still-image files
CVideoCaptureFrameGrabber	OpenCV VideoCapture-based IFrameGrabber for video files. Returns a new frame from TryGrab only when the source advances at the video frame rate
►NOptions
CCameraOpenOptions	One-shot open options for camera sources
CImageFileOpenOptions	One-shot open options for still-image file sources
CVideoCaptureOpenOptions	One-shot open options for OpenCV VideoCapture file sources
CVideoFileOpenOptions	One-shot open options for video file sources
CCameraDeviceInfo	Describes a camera device entry for device enumeration
CCameraResolution	Describes a supported camera resolution mode
CCameraResolutionUtils	Optional helpers for working with CameraResolution lists returned by camera sources
CFPSThrottle	Throttles callbacks to a target frame rate, or invokes every tick when the target FPS is zero or negative. Used internally by image mat sources and video grabbers; not a primary public contract
CICameraFacingControllable	Front or back camera facing selection for camera sources
CICameraMatSource	Camera-specific capabilities for IMatSource
CIFrameOrientationCorrector	Applies source-specific orientation correction after IFrameGrabber.TryGrab
CIImageFileMatSource	Still-image-specific capabilities for IMatSource
CImageFileMatSource	Still-image MatSourceBase that implements IImageFileMatSource and IMatUpdateFPSControllable
CIMatMetaProperties	Optional meta properties for SourceToMat sources. Unsupported keys return false from try methods without throwing
CIMatSource	Base contract for converting a media source into an owned, reusable FrameMat buffer
CIMatSourceDerivedFrames	Optional derived frame outputs registered on a IMatSource implementation
CIMatSourceEvents	Lifecycle, frame, and error events raised by a IMatSource implementation
CIMatSourceReinitializable	Initialization and re-initialization with playback state restoration for a IMatSource implementation
CIMatSourceTickable	Per-tick frame acquisition for a IMatSource implementation
CIMatTransformable	User-controlled rotation and flip operations applied to the output IMatSource.FrameMat
CIMatUpdateFPSControllable	Controls how often the output IMatSource.FrameMat is updated while playing, for sources that have no native frame rate (for example still images or arbitrary texture readback)
CInitTimeoutBudget	Shared initialization timeout budget for Grabbers.IFrameGrabber.OpenAsync and first-frame wait. Time spent inside RunOutsideTimeoutAsync does not consume the budget (for example long-running host prompts such as OS permission dialogs). A timeout of zero or less means unlimited
CISourceToMatErrorSource	Optional capability for components that report expected runtime failures through SourceToMatErrorCode
CIVideoCaptureMatSource	OpenCV VideoCapture-specific capabilities for file-based video sources
CIVideoFileMatSource	Video-file playback capabilities shared by file-based video sources
CMatSourceBase	Concrete IMatSource that drives an injected IFrameGrabber and an optional IFrameOrientationCorrector. Owns _frameMat, a lazy _rotatedBuffer used only for user 90-degree rotation, and a lazy orientation scratch used only when orientation correction needs a swapped-size buffer and the output color format differs from the grabber. When user rotation is off, _rotatedBuffer is released. When the orientation scratch is not required, it is released. Grabber frames from IFrameGrabber.TryGrab are treated as read-only. Implements IMatTransformable only; IMatUpdateFPSControllable is implemented by derived sources such as ImageFileMatSource and by integration-layer mat sources that throttle texture readback. Also implements IMatSourceEvents, IMatSourceTickable, IMatSourceReinitializable, and IMatSourceDerivedFrames for host event subscription, per-tick acquisition, source-swap re-initialization, and derived frame registration
CSourceToMatException	Thrown for SourceToMat contract violations (for example, use after IDisposable.Dispose, or invalid state transitions). Expected runtime failures are reported via SourceToMatErrorCode on the error event instead
CSourceToMatHostMarshaling	Shared helpers for captured main-thread affinity and marshaling in host-integrated SourceToMat grabbers
CSourceToMatHostWait	Host message-loop wait loop for SourceToMat grabber Open waits
CSourceToMatMetaKeys	Engine-independent meta property keys for IMatMetaProperties. Engine-specific keys belong in the host integration layer
CSourceToMatOpenOptionsProjection	Projects one-shot *OpenOptions DTO values onto matching Requested* source properties
CSourceToMatSynchronizationContextScope	Temporarily restores a captured SynchronizationContext for the current async flow
CSourceToMatUtils	Static helpers for color-format conversion and Mat geometric transforms used by SourceToMat
CSourceToMatWait	Shared wait loop for SourceToMat initialization and first-frame waits
CVideoCaptureMatSource	OpenCV VideoCapture-backed MatSourceBase that implements IVideoCaptureMatSource
►NWorker
►NDataStruct
CClassificationData	Packed top-1 classification result (confidence and class id) for DNN worker output buffers
CFaceDetection5LandmarkData	Packed face-detection result with a bounding box, five facial landmarks, and a confidence score for DNN worker output buffers
CObjectDetectionData	Packed object-detection result (axis-aligned bounding box, confidence, and class id) for DNN worker output buffers
CPoseEstimationCOCO17Data	Packed COCO 17-keypoint pose-estimation result (bounding box, confidence, class id, and landmarks) for DNN worker output buffers
CPoseEstimationCOCO17DataUnsafe	Deprecated compatibility wrapper around PoseEstimationCOCO17Data
►NDnnModule
►NMediaPipe
CMediaPipeFaceLandmarker	MediaPipe FaceLandmarker using OpenCV DNN via OpenCVDnnInferenceNet
►CMediaPipeFaceLandmarkerBase	Shared MediaPipe FaceLandmarker algorithm implementation for any IDnnInferenceNet backend. Reproduces the face landmarking graph logic of MediaPipe FaceLandmarker on top of the OpenCV Net 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
CFaceDetectorGraphResult	Bundled outputs of FaceDetectorGraph, corresponding to the upstream DETECTIONS, FACE_RECTS, and EXPANDED_FACE_RECTS streams in face_detector_graph.cc
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 <see cref="OpenCVForUnity.Extensions.Vec3f"/> values. Face-level raw presence scores are not included; the internal threshold is configured by the MediaPipeFaceLandmarkerBase<OpenCVForUnity.Extensions.Worker.DnnModule.IDnnInferenceNet> constructor
CFaceResult	Intermediate result for one face before packing. Downstream subgraph implementations fill each field before packing
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
CNormalizedRect	Face ROI looped back from the previous frame, corresponding to the upstream NormalizedRect packet
CMediaPipeHandLandmarker	MediaPipe HandLandmarker using OpenCV DNN via OpenCVDnnInferenceNet
►CMediaPipeHandLandmarkerBase	Shared MediaPipe HandLandmarker algorithm implementation for any IDnnInferenceNet backend. Reproduces the hand landmarking graph logic of MediaPipe HandLandmarker on top of the OpenCV Net 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 <see cref="OpenCVForUnity.Extensions.Vec3f"/> values. WorldLandmarks corresponds to the MediaPipe Task API hand_world_landmarks output
CHandResult	Lightweight structure representing the result for one detected hand. Landmarks stores normalized image coordinates after LandmarkProjectionCalculator, matching the semantics of NormalizedLandmark: x, y, z are expected in the [0, 1] range and z corresponds to landmark.z * NORM_RECT.width
CNormalizedRect	Structure representing a hand ROI looped back from the previous frame. Equivalent to a MediaPipe-style normalized rectangle
CMediaPipeHolisticLandmarker	MediaPipe HolisticLandmarker using OpenCV DNN via OpenCVDnnInferenceNet
►CMediaPipeHolisticLandmarkerBase	Shared MediaPipe HolisticLandmarker algorithm implementation for any IDnnInferenceNet backend. Reproduces the holistic landmarking graph logic of MediaPipe HolisticLandmarker on top of the OpenCV Net DNN module
CHolisticFaceLandmarkPseudoDetection	Pseudo detection for LandmarksToDetectionCalculator, including 478 keypoints
CHolisticFaceTrackFrameResult	Per-frame result from TrackHolisticFace before BuildHolisticPackedOutputs
CHolisticHandNormRectBridge
CHolisticHandRoiRefinePreprocessOut
CHolisticHandTrackFrameResult	Per-hand result from TrackHolisticHand before BuildHolisticPackedOutputs
CHolisticHandTrackingRequest	Equivalent to upstream MediaPipe HolisticHandTrackingRequest
CHolisticLandmarkerFrameResult	One-frame inference result from HolisticLandmarkerGraph before PackResultsToMats. This is analogous to MediaPipePoseLandmarkerBase<OpenCVForUnity.Extensions.Worker.DnnModule.IDnnInferenceNet>'s List<PoseResult>
CHolisticNormalizedRect	Equivalent to upstream MediaPipe NormalizedRect, used for Holistic pose ROI loopback
CHolisticPoseDetectionData
CHolisticPoseDetectorGraphResult
CHolisticPoseHandIndices	Equivalent to PoseIndices in holistic_hand_tracking.cc
CHolisticPoseLandmarkDecoded
CHolisticPoseTrackFrameResult	Intermediate one-frame result from TrackHolisticPose before MediaPipeHolisticLandmarkerBase<TNet>.BuildHolisticPackedOutputs
CHolisticPoseTrackingRequest	Equivalent to upstream MediaPipe HolisticPoseTrackingRequest, which holistic_landmarker_graph.cc passes to TrackHolisticPose
CHolisticSingleFaceGraphFaceResult
CHolisticSingleFaceLmPreprocessOut
CHolisticSingleHandGraphResult
CHolisticSingleHandLmPreprocessOut
CHolisticSinglePoseLandmarkPreprocessOut
CHolisticSinglePoseLandmarksInnerResult
CMediaPipePoseLandmarker	MediaPipe PoseLandmarker using OpenCV DNN via OpenCVDnnInferenceNet
►CMediaPipePoseLandmarkerBase	Shared MediaPipe PoseLandmarker algorithm implementation for any IDnnInferenceNet backend. Reproduces the pose landmarking graph logic of MediaPipe PoseLandmarker on top of the OpenCV Net DNN module
CNormalizedRect	Pose ROI looped back from the previous frame. Equivalent to a MediaPipe NormalizedRect
CPoseDetectionData	One pose detection after letterbox removal, expressed in coordinates relative to the input image. Corresponds to the LOCATION_DATA payload of the original Detection
CPoseDetectorGraphResult	Bundled outputs of PoseDetectorGraph. Corresponds to DETECTIONS, POSE_RECTS, and EXPANDED_POSE_RECTS in the original pose_detector_graph.cc
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
CPoseResult	Intermediate result for one pose before packing. Filled by the lower-level subgraph implementations
►NYOLOv5
CYOLOv5ImageClassifier	YOLOv5 image classifier using OpenCV DNN via OpenCVDnnInferenceNet
CYOLOv5ImageClassifierBase	Shared YOLOv5 image-classification algorithm implementation for any IDnnInferenceNet backend
CYOLOv5InstanceSegmenter	YOLOv5 instance segmenter using OpenCV DNN via OpenCVDnnInferenceNet
CYOLOv5InstanceSegmenterBase	Shared YOLOv5 instance-segmentation algorithm implementation for any IDnnInferenceNet backend
CYOLOv5ObjectDetector	YOLOv5 object detector using OpenCV DNN via OpenCVDnnInferenceNet
CYOLOv5ObjectDetectorBase	Shared YOLOv5 object-detection algorithm implementation for any IDnnInferenceNet backend
►NYOLOv8
CYOLOv8ImageClassifier	YOLOv8 image classifier using OpenCV DNN via OpenCVDnnInferenceNet
CYOLOv8ImageClassifierBase	Shared YOLOv8 image-classification algorithm implementation for any IDnnInferenceNet backend
CYOLOv8InstanceSegmenter	YOLOv8 instance segmenter using OpenCV DNN via OpenCVDnnInferenceNet
CYOLOv8InstanceSegmenterBase	Shared YOLOv8 instance-segmentation algorithm implementation for any IDnnInferenceNet backend
CYOLOv8ObjectDetector	YOLOv8 object detector using OpenCV DNN via OpenCVDnnInferenceNet
CYOLOv8ObjectDetectorBase	Shared YOLOv8 object-detection algorithm implementation for any IDnnInferenceNet backend
CYOLOv8PoseEstimater	YOLOv8 pose estimator using OpenCV DNN via OpenCVDnnInferenceNet
CYOLOv8PoseEstimaterBase	Shared YOLOv8 pose-estimation algorithm implementation for any IDnnInferenceNet backend
CDAMOYOLOObjectDetector	DAMO-YOLO object detector using OpenCV DNN via OpenCVDnnInferenceNet
CDAMOYOLOObjectDetectorBase	Shared DAMO-YOLO object-detection algorithm implementation for any IDnnInferenceNet backend
CDnnInferenceWorkerBase	Base class for ProcessingWorkerBase derivatives that record DNN runtime options (DnnBackend / DnnTarget / DnnEngine)
►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 using OpenCV DNN via OpenCVDnnInferenceNet
CFacialExpressionRecognizerBase	Shared facial expression recognition algorithm implementation for any IDnnInferenceNamedIONet backend
CIDnnAsyncInferenceNet	Optional capability: asynchronous forward with a list of named outputs
CIDnnAsyncNamedOutputInferenceNet	Optional capability: asynchronous forward for a single named output
CIDnnInferenceNamedIONet	Optional capability: named input/output for classification and multi-input models
CIDnnInferenceNet	Contract for a synchronous DNN inference net (OpenCV Net equivalent) used by DNN-based workers
CNanoDetPlusObjectDetector	NanoDetPlus object detector using OpenCV DNN via OpenCVDnnInferenceNet
CNanoDetPlusObjectDetectorBase	Shared NanoDetPlus object-detection algorithm implementation for any IDnnInferenceNet backend
COpenCVDnnInferenceDnn	Factory for OpenCV DNN graphs, analogous to Dnn for OpenCVDnnInferenceNet
COpenCVDnnInferenceNet	Thin wrapper around OpenCV Net that implements IDnnInferenceNet and IDnnInferenceNamedIONet
COpenCVDnnInferenceUtils	Helpers for mapping OpenCVDnnInferenceBackendKind, OpenCVDnnInferenceTargetKind, and OpenCVDnnInferenceEngineKind to OpenCV DNN runtime ids and UI labels
CYOLOXObjectDetector	YOLOX object detector using OpenCV DNN via OpenCVDnnInferenceNet
CYOLOXObjectDetectorBase	Shared YOLOX object-detection algorithm implementation for any IDnnInferenceNet backend
CYuNetV2FaceDetector	YuNetV2 face detector using OpenCV DNN via FaceDetectorYN
►NUtils
CClassLabelUtils	Utility class for handling class labels and names
CDnnInferenceNetUnconnectedOutLayersNames	Shared ordering contract for DnnModule.IDnnInferenceNet.GetUnconnectedOutLayersNames and DnnModule.IDnnInferenceNet.Forward(System.Collections.Generic.List<CoreModule.Mat>, System.Collections.Generic.List<string>)
CDnnNmsUtils	Utility class for OpenCV DNN non-maximum suppression (NMS) helpers
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	Contract for processing workers that accept input Mats and expose output Mats
►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)
CMatBufferUtils	OpenCV Mat buffer copy utilities
►COpenCVARUtils	OpenCV AR utilities (engine-independent: drawing, frustum, projection, pose, Mat4d TRS)
CMat4d	4×4 matrix (row-major layout: mRC is row R, column C)
CPoseData	Position and rotation pose data for AR utilities. Rotation is a unit quaternion stored as (x, y, z, w)
COpenCVDebug	OpenCV Debug 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]
►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
►NFeaturesModule
CAffineFeature	Class for implementing the wrapper which makes detectors and extractors to be affine invariant, described as ASIFT in [YM11]
CALIKED	ALIKED feature detector and descriptor extractor
CALIKED_Params
CANNIndex
CBFMatcher	Brute-force descriptor matcher
CDescriptorMatcher	Abstract base class for matching keypoint descriptors
CDISK	DISK feature detector and descriptor, based on a DNN model
CFastFeatureDetector	Wrapping class for feature detection using the FAST method
CFeature2D	Abstract base class for 2D image feature detectors and descriptor extractors
CFeatures
CFlannBasedMatcher	Flann-based descriptor matcher
CGFTTDetector	Wrapping class for feature detection using the goodFeaturesToTrack function. :
CLightGlueMatcher	LightGlue feature matcher
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
►NGeometryModule
CGeometry
CMoments	Template class for moments
CMSTEdge	Represents an edge in a graph for Minimum Spanning Tree (MST) computation
CSubdiv2D
CUsacParams
►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
CFilter2DParams
CFontFace	Wrapper on top of a truetype/opentype/etc font, i.e. Freetype's FT_Face
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
CLineSegmentDetector	Line segment detector class
CMoments	Template class for moments
►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
CBoard	Board of ArUco markers
CCChecker	Checker object
CCCheckerDetector	A class to find the positions of the ColorCharts in the image
CCharucoBoard	ChArUco board is a planar chessboard where the markers are placed inside the white squares of a chessboard
CCharucoDetector
CCharucoParameters
CCirclesGridFinderParameters
CDetectorParameters	Struct DetectorParameters is used by ArucoDetector
CDetectorParametersMCC	Struct DetectorParametersMCC is used by CCheckerDetector
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
CObjdetect
CQRCodeDetector	QR code detector
CQRCodeDetectorAruco	QR code detector based on Aruco markers detection code
CQRCodeDetectorAruco_Params
CQRCodeEncoder	QR code encoder
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
CColorCorrectionModel	Core class of ccm model
CIntelligentScissorsMB	Intelligent Scissors image segmentation
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
►NPtcloudModule
COctree	Octree for 3D vision
COdometry
COdometryFrame	An object that keeps per-frame data for Odometry algorithms from user-provided images to algorithm-specific precalculated data. When not empty, it contains a depth image, a mask of valid pixels and a set of pyramids generated from that data. A BGR/Gray image and normals are optional. OdometryFrame is made to be used together with Odometry class to reuse precalculated data between Rt data calculations. A correct way to do that is to call Odometry.prepareFrames() on prev and next frames and then pass them to Odometry.compute() method
COdometrySettings
CPoseGraph
CPtcloud
CRgbdNormals
CTriangleRasterizeSettings	Structure to keep settings for rasterization
CVolume
CVolumeSettings
►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]
►NStereoModule
CStereo
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:
►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	Manages AR camera calibration parameters and Unity Camera.projectionMatrix for the AR pipeline. Supplies intrinsics, distortion coefficients, and an OpenCV-space projection matrix to ARGameObject / Extensions.AR.ARPoseEstimator
CARGameObject	Unity integration layer for an AR object that works with ARCamera. Bridges Inspector settings and Vector2[]/Vector3[] point data to ARPoseEstimator, then applies the returned pose via ConvertPoseDataToMatrix and UpdateTransform
CARHelper	The ARHelper class manages ARCamera and ARGameObjects, automating the calculation of ARMatrix and updating the Transform of the specified UpdateTarget
►NInteraction
CDragRotationController	DragRotationController A component that rotates a target GameObject based on pointer drag input. The rotation is calculated from the pointer delta movement, allowing intuitive drag-to-rotate interaction. Supports both mouse and touch input through Unity's Pointer Events system
►CTextureSelector	TextureSelector A component that detects touch/click on GameObject and converts screen coordinates to texture coordinates. Supports Quad mesh with Renderer component and RawImage UI elements. Provides both point selection and rectangle selection modes with OpenCV coordinate system support
CTextureSelectionEvent	Unity event fired when texture selection state has changed. Can be configured in the Inspector. Parameters: GameObject (target object), TextureSelectionState (current state), Vector2[] (texture coordinates)
►NOptimization
CImageOptimizationHelper	A helper component for optimizing image processing in Unity by managing frame skipping and downscaling operations
►NSourceToMat
►NGrabbers
CAsyncGPUReadbackFrameGrabber	AsyncGPUReadback-based IFrameGrabber for Unity Texture sources. Returns a new frame from TryGrab only when a capture request has completed (or when delivering the first frame captured during OpenAsync). The Open body runs inside SourceToMatSynchronizationContextScope
CIUnityFrameGrabberPlayback	Optional playback control for Unity SourceToMat grabbers that drive a playing capture device or player
CIWebCamFrameGrabMetadata	Read-only WebCam frame metadata for orientation correction
CUnityVideoPlayerFrameGrabber	Unity VideoPlayer-based IFrameGrabber for video files. Returns a new frame from TryGrab only when the player advances to a new frame. During playback, TryGrab also polls VideoPlayer.frame so frame delivery continues when VideoPlayer.frameReady events are not delivered
CWebCamTextureAsyncGPUReadbackFrameGrabber	AsyncGPUReadback-based WebCamTexture IFrameGrabber. Returns a new frame from TryGrab only when a capture request has completed (or when delivering the first frame captured during OpenAsync). The Open body runs inside SourceToMatSynchronizationContextScope
CWebCamTextureFrameGrabber	Synchronous WebCamTexture-based IFrameGrabber. Returns a new frame from TryGrab only when WebCamTexture.didUpdateThisFrame is true (or when delivering the first frame captured during OpenAsync). The Open body runs inside SourceToMatSynchronizationContextScope
CWebCamTextureGrabberUtils	Shared WebCam permission, device resolution, enumeration, and autofocus meta helpers for WebCam grabbers
►NOptions
CAsyncGPUReadbackOpenOptions	One-shot open options for AsyncGPUReadback-backed texture sources
CUnityVideoPlayerOpenOptions	One-shot open options for Unity VideoPlayer-backed video file sources
CWebCamTextureOpenOptions	One-shot open options for Unity WebCamTexture-backed camera sources
CWebCamTextureOpenOptionsProjection	Projects WebCamTextureOpenOptions onto camera / facing targets and grabber open settings
►NOrientation
CWebCamFrameOrientationCorrector	Applies WebCam-specific orientation correction after IFrameGrabber.TryGrab
CAsyncGPUReadbackMatSource	AsyncGPUReadback-backed MatSourceBase that implements IUnityTextureMatSource
CAsyncGPUReadbackSourceInspectorSettings	Unity-serializable source inspector settings for AsyncGPUReadbackToMatHelper
CAsyncGPUReadbackToMatHelper	Unity helper that reads Texture sources via AsyncGPUReadback and exposes frames through AsyncGPUReadbackMatSource. Primary Unity entry for texture readback; use SourceToMatHelperBase.MatSource for advanced access; use MultiSourceToMatHelper to switch helper kinds
CDerivedFrameInspectorGroup	Inspector foldout grouping derived frame settings and layout-changed event wiring
CDerivedFrameInspectorSettings	Unity-serializable derived frame settings for SourceToMatHelperBase
CDerivedFrameLayoutChangedUnityEvent	UnityEvent invoked when a derived frame layout changes after initialization
CErrorEventsInspectorGroup	Inspector foldout grouping error UnityEvents for SourceToMatHelperBase
CFrameEventsInspectorGroup	Inspector foldout grouping frame delivery UnityEvents for SourceToMatHelperBase
CICameraFacingToMatHelperControls	Helper-facing controls for front or back camera facing selection. Custom camera helpers that support facing should implement this so UI and tools can change the request through the helper public API (not by writing MatSource directly)
CICameraToMatHelperControls	Helper-facing controls for camera sources (device, resolution, and FPS requests). Custom helpers that wrap a camera mat source should implement this so UI and tools can change requests through the helper public API (not by writing MatSource directly). Facing selection is provided separately by ICameraFacingToMatHelperControls
CIImageFileToMatHelperControls	Helper-facing controls for image-file sources. Custom helpers that wrap an image-file mat source should implement this so UI and tools can change requests through the helper public API (not by writing MatSource directly)
CImageFileSourceInspectorSettings	Unity-serializable source inspector settings for ImageFileToMatHelper
CImageFileToMatHelper	Unity helper that loads a still image file via ImageFileFrameGrabber and exposes frames through ImageFileMatSource. Primary Unity entry for image files; use SourceToMatHelperBase.MatSource for advanced access; use MultiSourceToMatHelper to switch helper kinds
CIMatUpdateFPSToMatHelperControls	Helper-facing controls for mat-update FPS throttling on sources without a native frame rate. Custom helpers that expose mat-update FPS should implement this so UI and tools can change the request through the helper public API (not by writing MatSource directly)
CIUnityCameraMatSource	Unity WebCam device enumeration capabilities for camera IMatSource implementations
CIUnityCameraPoseProvider	Unity camera pose matrices for camera OpenCVForUnity.Extensions.SourceToMat.IMatSource implementations
CIUnityCameraToMatHelperControls	Helper-facing Unity WebCam device enumeration. Optional supplement to ICameraToMatHelperControls when Unity device metadata is available
CIUnityTextureMatSource	Texture-backed IMatSource capabilities for Unity integration helpers
CIUnityTextureToMatHelperControls	Helper-facing controls for Unity texture-backed sources. Custom helpers that wrap a texture mat source should implement this so UI and tools can change the source through the helper public API (not by writing MatSource directly)
CIUnityVideoFileMatSource	Unity VideoPlayer-backed video-file IMatSource capabilities
CIVideoFileToMatHelperControls	Helper-facing controls for video-file sources. Custom helpers that wrap a video-file mat source should implement this so UI and tools can change requests through the helper public API (not by writing MatSource directly)
CLifecycleEventsInspectorGroup	Inspector foldout grouping lifecycle UnityEvents for SourceToMatHelperBase
CMultiSourcePerKindSettings	Per-kind inspector setting cache used by MultiSourceToMatHelper when swapping the active child helper (Pull before destroy, Push after add)
CMultiSourceToMatHelper	Secondary facade that switches the active SourceToMatHelperBase kind on this GameObject. Primary Unity entry remains a concrete *ToMatHelper; use ActiveHelper and its SourceToMatHelperBase.MatSource (and capability interfaces) for advanced access
CSourceToMatCommonInspectorSettings	Unity-serializable common inspector settings shared by SourceToMatHelperBase and MultiSourceToMatHelper
CSourceToMatErrorUnityEvent	UnityEvent carrying a SourceToMatErrorCode and an optional message from SourceToMat helpers
CSourceToMatHelperBase	Abstract base for Unity MonoBehaviour helpers that expose a wrapped IMatSource. Primary Unity entry is a concrete *ToMatHelper; use MatSource (and capability interfaces) for advanced access; use MultiSourceToMatHelper to switch helper kinds. Does not implement IMatSource; derived helpers own inspector fields and wire a concrete source
CSourceToMatUnityMainThreadUtils	Unity-specific SourceToMat integration notes and strict main-thread affinity for Helpers.SourceToMatHelperBase components
CSourceToMatUnityMetaKeys	Unity-specific meta property keys for OpenCVForUnity.Extensions.SourceToMat.IMatMetaProperties
CSourceToMatUnityPath	Resolves Unity-side file paths for SourceToMat helpers. Accepts a path relative to the StreamingAssets folder or an absolute URI/path string, and returns a host-resolved readable path for Extensions grabbers and options
CUnityCameraDeviceInfo	Describes a Unity WebCam device entry for device enumeration
CUnityVideoPlayerMatSource	Unity VideoPlayer-backed MatSourceBase that implements IUnityVideoFileMatSource
CUnityVideoPlayerSourceInspectorSettings	Unity-serializable source inspector settings for UnityVideoPlayerToMatHelper
CUnityVideoPlayerToMatHelper	Unity helper that reads video files via VideoPlayer and exposes frames through UnityVideoPlayerMatSource implementing IUnityVideoFileMatSource. Primary Unity entry for Unity VideoPlayer files; use SourceToMatHelperBase.MatSource for advanced access; use MultiSourceToMatHelper to switch helper kinds
CVideoCaptureSourceInspectorSettings	Unity-serializable source inspector settings for VideoCaptureToMatHelper
CVideoCaptureToMatHelper	Unity helper that reads video files via OpenCV VideoCapture and exposes frames through VideoCaptureMatSource. Primary Unity entry for OpenCV VideoCapture files; use SourceToMatHelperBase.MatSource for advanced access; use MultiSourceToMatHelper to switch helper kinds
CWebCamTextureMatSource	Unity WebCamTexture-backed MatSourceBase that implements IUnityCameraMatSource, ICameraFacingControllable, and IUnityCameraPoseProvider
CWebCamTextureSourceInspectorSettings	Unity-serializable source inspector settings for WebCamTextureToMatHelper
CWebCamTextureToMatHelper	Unity helper that reads WebCam frames via WebCamTexture and exposes them through WebCamTextureMatSource implementing IUnityCameraMatSource. Primary Unity entry for webcam capture; use SourceToMatHelperBase.MatSource for advanced access; use MultiSourceToMatHelper to switch helper kinds
►NUI
CFpsMonitor	FpsMonitor Displays FPS and optional key-value diagnostics in a screen overlay, plus a bottom console bar for status messages. UI is created at runtime from a Canvas prefab and scales with screen resolution via Canvas Scaler
►CSourceToMatControlPanel	Runtime control panel for SourceToMat helpers. Loads UI from a Canvas prefab under Resources, wires transport, transform, and capability controls through SourceToMatControlTarget, and exposes UnityEvent hooks after helper updates
CBoolUnityEvent	Serializes a UnityEvent<T0> of bool for the Inspector
CCapabilityHooks	Capability UnityEvent hooks (paths, camera, texture, kind, mat-update FPS, seek). Nested for Inspector foldout grouping
CFloatUnityEvent	Serializes a UnityEvent<T0> of float for the Inspector
CIntUnityEvent	Serializes a UnityEvent<T0> of int (helper kind) for the Inspector
CStringUnityEvent	Serializes a UnityEvent<T0> of string for the Inspector
CTextureUnityEvent	Serializes a UnityEvent<T0> of Texture for the Inspector
CTransformHooks	Transform UnityEvent hooks (Rotate90 / FlipVertical / FlipHorizontal). Nested for Inspector foldout grouping
CTransportHooks	Transport UnityEvent hooks (Play / Pause / Stop / Initialize / Release). Nested for Inspector foldout grouping
►CSourceToMatControlPanelDefaults	Inspector-default capability snapshots used by SourceToMatControlPanel dropdown rows labeled Default:
CCapabilitySnapshot	Captured default values for one helper kind or a single-helper target
►CSourceToMatControlPresets	Inspector presets used by SourceToMatControlPanel capability sections (image/video paths, camera device/resolution, source textures, and mat-update FPS)
CDevicePreset	Labeled camera device override or favorite entry
CMatUpdateFPSPreset	Labeled mat-update FPS preset for helpers that implement mat-update FPS control
CPathPreset	Labeled file path preset (image or video)
CResolutionPreset	Labeled camera resolution and FPS preset
CTexturePreset	Labeled Texture preset for Unity texture-backed helpers
CSourceToMatControlTarget	Thin facade that resolves either a MultiSourceToMatHelper or a SourceToMatHelperBase and forwards transport, transform, and read-only MatSource access through the helper public API
►NWorker
►NDnnModule
►NMediaPipe
►NSkeletonVisualizer
CMediaPipeFaceSkeletonVisualizer	Visualizes a 3D face skeleton with LineRenderer from MediaPipe face landmarker 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 MediaPipeHandLandmarkerMultiBackend 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 MediaPipePoseLandmarkerMultiBackend
►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	Obsolete compatibility alias for MediaPipeFaceLandmarkerMultiBackend
CMediaPipeFaceLandmarkerMultiBackend	MediaPipe FaceLandmarker with Unity multi-backend inference (OpenCV DNN and Sentis)
CMediaPipeHandLandmarker	Obsolete compatibility alias for MediaPipeHandLandmarkerMultiBackend
CMediaPipeHandLandmarkerMultiBackend	MediaPipe HandLandmarker with Unity multi-backend inference (OpenCV DNN and Sentis)
CMediaPipeHolisticLandmarker	Obsolete compatibility alias for MediaPipeHolisticLandmarkerMultiBackend
CMediaPipeHolisticLandmarkerMultiBackend	MediaPipe HolisticLandmarker with Unity multi-backend inference (OpenCV DNN and Sentis)
CMediaPipePoseLandmarker	Obsolete compatibility alias for MediaPipePoseLandmarkerMultiBackend
CMediaPipePoseLandmarkerMultiBackend	MediaPipe PoseLandmarker with Unity multi-backend inference (OpenCV DNN and Sentis)
►NYOLOv5
CYOLOv5ImageClassifier	Obsolete compatibility alias for YOLOv5ImageClassifierMultiBackend
CYOLOv5ImageClassifierMultiBackend	YOLOv5 image classifier with Unity multi-backend inference (OpenCV DNN and Sentis)
CYOLOv5InstanceSegmenter	Obsolete compatibility alias for YOLOv5InstanceSegmenterMultiBackend
CYOLOv5InstanceSegmenterMultiBackend	YOLOv5 instance segmenter with Unity multi-backend inference (OpenCV DNN and Sentis)
CYOLOv5ObjectDetector	Obsolete compatibility alias for YOLOv5ObjectDetectorMultiBackend
CYOLOv5ObjectDetectorMultiBackend	YOLOv5 object detector with Unity multi-backend inference (OpenCV DNN and Sentis)
►NYOLOv8
CYOLOv8ImageClassifier	Obsolete compatibility alias for YOLOv8ImageClassifierMultiBackend
CYOLOv8ImageClassifierMultiBackend	YOLOv8 image classifier with Unity multi-backend inference (OpenCV DNN and Sentis)
CYOLOv8InstanceSegmenter	Obsolete compatibility alias for YOLOv8InstanceSegmenterMultiBackend
CYOLOv8InstanceSegmenterMultiBackend	YOLOv8 instance segmenter with Unity multi-backend inference (OpenCV DNN and Sentis)
CYOLOv8ObjectDetector	Obsolete compatibility alias for YOLOv8ObjectDetectorMultiBackend
CYOLOv8ObjectDetectorMultiBackend	YOLOv8 object detector with Unity multi-backend inference (OpenCV DNN and Sentis)
CYOLOv8PoseEstimater	Obsolete compatibility alias for YOLOv8PoseEstimaterMultiBackend
CYOLOv8PoseEstimaterMultiBackend	YOLOv8 pose estimator with Unity multi-backend inference (OpenCV DNN and Sentis)
CDAMOYOLOObjectDetector	Obsolete compatibility alias for DAMOYOLOObjectDetectorMultiBackend
CDAMOYOLOObjectDetectorMultiBackend	DAMO-YOLO object detector with Unity multi-backend inference (OpenCV DNN and Sentis)
CFaceIdentificationEstimator
CFacialExpressionRecognizer	Obsolete compatibility alias for FacialExpressionRecognizerMultiBackend
CFacialExpressionRecognizerMultiBackend	Facial expression recognizer with Unity multi-backend inference (OpenCV DNN and Sentis)
CInferenceFrameworkUtils	Helpers for mapping InferenceFrameworkSelectionKind to InferenceFrameworkKind and UI labels
CMultiBackendDnn	Subset of OpenCV OpenCVForUnity.DnnModule.Dnn for loading models that may run on either OpenCV DNN or Sentis (com.unity.ai.inference)
CMultiBackendNet	Closed facade over OpenCV DNN or Sentis inference nets, with deferred initialization after MultiBackendDnn.ReadNet. Implements IDnnInferenceNamedIONet and, as a type, IDnnAsyncInferenceNet / IDnnAsyncNamedOutputInferenceNet (async methods throw on the OpenCV path)
CNanoDetPlusObjectDetector	Obsolete compatibility alias for NanoDetPlusObjectDetectorMultiBackend
CNanoDetPlusObjectDetectorMultiBackend	NanoDetPlus object detector with Unity multi-backend inference (OpenCV DNN and Sentis)
CSentisInferenceDnn	Factory for Sentis (Unity Inference Engine) inference nets, parallel to OpenCV Dnn.readNet
CSentisInferenceNet	Sentis (Unity Inference Engine) implementation of IDnnInferenceNamedIONet with optional asynchronous forward via IDnnAsyncInferenceNet and IDnnAsyncNamedOutputInferenceNet
CSentisInferenceUtils	Helpers for mapping SentisInferenceBackendKind and SentisInferenceTargetKind to Sentis runtime ids and UI labels
CYOLOXObjectDetector	Obsolete compatibility alias for YOLOXObjectDetectorMultiBackend
CYOLOXObjectDetectorMultiBackend	YOLOX object detector with Unity multi-backend inference (OpenCV DNN and Sentis)
CYuNetV2FaceDetector	Obsolete compatibility alias for OpenCVForUnity.Extensions.Worker.DnnModule.YuNetV2FaceDetector
CDebugMat	OpenCV highgui-style debug image display utilities for Unity (imshow, destroyWindow, etc.)
COpenCVForUnityEnv	OpenCV for Unity environment utilities
COpenCVMatUnityUtils	OpenCV Mat Unity integration utilities
►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
CECCParameters	Struct ECCParameters is used by findTransformECCMultiScale
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
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
CAgastFeatureDetector	Wrapping class for feature detection using the AGAST method. :
CAKAZE	Class implementing the AKAZE keypoint detector and descriptor extractor, described in [ANB13]
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]
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
CBriefDescriptorExtractor	Class for computing BRIEF descriptors described in [calon2010]
CBRISK	Class implementing the BRISK keypoint detector and descriptor extractor, described in [LCS11]
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]
CKAZE	Class implementing the KAZE keypoint detector and descriptor extractor, described in [ABD12]
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
►NXobjdetectModule
CBaseCascadeClassifier
CCascadeClassifier	Cascade classifier class for object detection
CHOGDescriptor	Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector
CXobjdetect
►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	Base class for disposable OpenCV wrapper types implementing the standard dispose pattern
CDisposableOpenCVObject	Base class for OpenCV C++ wrapper objects that hold a native pointer in _nativeObj
CEngineLog	Centralizes engine-specific log output
CILogger	Abstraction for engine-specific log output
CNativeLibraryName	Centralizes the native OpenCV library name used by DllImport
CApplicationException
CIAsyncDisposable
CIBeginDragHandler
CICancelHandler
CIComparable
CIDisposable
CIDragHandler
CIEndDragHandler
CIEquatable
CInvalidOperationException
CIPointerDownHandler
CIPointerUpHandler
CIStructuralComparable
CIStructuralEquatable
CMediaPipeHolisticLandmarkerBase
CMonoBehaviour