Namespace OpenCvSharp

Classes

ALIKED: ALIKED: deep learning based local feature detector and descriptor (OpenCV 5). Runs an ONNX model through the DNN module. Requires OpenCV built with the dnn module.

ANNIndex: Approximate nearest neighbor index backed by Annoy (OpenCV 5), a modern alternative to FLANN.

AffineFeature: Class implementing the AKAZE-style affine-invariant feature wrapper (ASIFT and friends). It wraps another Feature2D backend and applies it over a set of simulated affine (tilt/rotation) views of the image. See Y. Yu, J.M. Morel "ASIFT".

AffineTransformer: Affine shape transformer.

Algorithm: Base class for high-level OpenCV algorithms

Animation: Represents an animation with multiple frames. Stores and manages 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.

BFMatcher: Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one.

BackgroundSubtractor: The Base Class for Background/Foreground Segmentation. The class is only used to define the common interface for the whole family of background/foreground segmentation algorithms.

BackgroundSubtractorCNT: Background subtraction based on counting. About as fast as MOG2 on a high end system. More than twice faster than MOG2 on cheap hardware (benchmarked on Raspberry Pi3).

BackgroundSubtractorGMG: Background Subtractor module. Takes a series of images and returns a sequence of mask (8UC1) images of the same size, where 255 indicates Foreground and 0 represents Background.

BackgroundSubtractorGSOC: Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper. This algorithm demonstrates better performance on CDNET 2014 dataset compared to other algorithms in OpenCV.

BackgroundSubtractorKNN: K nearest neigbours algorithm

BackgroundSubtractorLSBP: Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at "Local SVD Binary Pattern (LSBP) for Background Subtraction in Complex Scenes" (Guo et al., 2016).

BackgroundSubtractorLSBPDesc: This is for calculation of the LSBP descriptors.

BackgroundSubtractorMOG: Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm

BackgroundSubtractorMOG2: The Base Class for Background/Foreground Segmentation. The class is only used to define the common interface for the whole family of background/foreground segmentation algorithms.

BarcodeDetector: BarcodeDetector use a super resolution model. super resolution model is applied to zoom in Barcode when it is small.

BroxOpticalFlow

CLAHE: Contrast Limited Adaptive Histogram Equalization

CalibrateCRF: The base class for camera response calibration algorithms.

CalibrateDebevec: CalibrateDebevec object

CalibrateRobertson: CalibrateRobertson object

CascadeClassifier: Cascade classifier class for object detection.

ChiHistogramCostExtractor: A chi-squared based histogram cost extractor.

ConnectedComponents: connected components that is returned from Cv2.ConnectedComponentsEx

ConnectedComponents.Blob: One blob

Cv2: OpenCV Functions of C++ I/F (cv::xxx)

Cv2.Aruco: aruco module

Cv2.Detail: cv::detail functions

Cv2.Dnn: cv::dnn functions

Cv2.FishEye: The methods in this class use a so-called fisheye camera model.

Cv2.OptFlow: cv::optflow functions

Cv2.Text: cv::text functions

Cv2.VideoIORegistry: cv::videoio_registry functions. This section contains API description how to query/configure available Video I/O backends.

Cv2.XImgProc: cv::ximgproc functions

Cv2.XImgProc.RL: run_length_morphology.hpp

Cv2.XImgProc.Segmentation: Strategy for the selective search segmentation algorithm.

Cv2.XPhoto: cv::xphoto functions

CvObject: Base class for objects that own a single native OpenCV pointer through an OpenCvSafeHandle. The SafeHandle is the single source of truth for the native handle value and is responsible for releasing it (including from its own finalizer when the managed object is dropped without Dispose()).

CvPtrObject: Base class for OpenCV Algorithm-hierarchy objects. The owned OpenCvSafeHandle (in CvObject) wraps the raw T* used for P/Invoke, so RawPtr, CvPtr and OpenCvSharp.CvObject.Handle all yield that pointer. When the object is owned through a cv::Ptr<T>* smart pointer, that smart pointer (kept in OpenCvSharp.CvPtrObject.smartPtr) is what gets released on disposal.

CvTrackbar: Trackbar that is shown on an OpenCV Window

DISK: DISK: deep learning based local feature detector and descriptor (OpenCV 5). Runs an ONNX model through the DNN module. Requires OpenCV built with the dnn module.

DenseOpticalFlowExt: Base class for high-level OpenCV algorithms

DescriptorMatcher

DetectionROI: struct for detection region of interest (ROI)

DualTVL1OpticalFlow

EM: The class implements the Expectation Maximization algorithm.

EMDHistogramCostExtractor: An EMD (Earth Mover Distance) based histogram cost extractor.

EMDL1HistogramCostExtractor: An EMD-L1 based histogram cost extractor.

FaceDetectorYN: DNN-based face detector

FaceRecognizerSF: DNN-based face recognizer

FarnebackOpticalFlow

FastFeatureDetector: Detects corners using FAST algorithm by E. Rosten

Feature2D: Abstract base class for 2D image feature detectors and descriptor extractors

FileNode: File Storage Node class

FileNodeIterator: Base class for objects that own a single native OpenCV pointer through an OpenCvSafeHandle. The SafeHandle is the single source of truth for the native handle value and is responsible for releasing it (including from its own finalizer when the managed object is dropped without Dispose()).

FileStorage: XML/YAML File Storage Class.

FileStorage.StructScope: Disposable scope returned by WriteStruct(string, Types, string?). Disposing it calls EndWriteStruct() on the owning FileStorage.

Filter2DParams: Parameters for the OpenCV 5 Filter2D(InputArray, OutputArray, InputArray, Filter2DParams?) overload. Mirrors cv::Filter2DParams; all fields are optional and default to the OpenCV defaults.

FlannBasedMatcher: Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one.

FontFace: TrueType font face used by the FontFace-based PutText(InputOutputArray, string, Point, Scalar, FontFace, int, int, PutTextFlags, Range?) and GetTextSize(Size, string, Point, FontFace, int, int, PutTextFlags, Range?) (OpenCV 5).

FrameSource

GFTTDetector: Good Features To Track Detector

GeneralizedHough: finds arbitrary template in the grayscale image using Generalized Hough Transform

GeneralizedHoughBallard: Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122. Detects position only without traslation and rotation

GeneralizedHoughGuil: Guil, N., González-Linares, J.M. and Zapata, E.L. (1999). Bidimensional shape detection using an invariant approach. Pattern Recognition 32 (6): 1025-1038. Detects position, translation and rotation

HOGDescriptor: HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector

HausdorffDistanceExtractor: A simple Hausdorff distance measure between shapes defined by contours

HierarchyIndex: Information about the image topology for cv::findContours

HistogramCostExtractor: Abstract base class for histogram cost algorithms used in shape matching.

ImageCollection: Reads multi-page images on demand. Decodes pages lazily as they are accessed. Performance of page decoding is O(1) when the collection is accessed sequentially; accessing a page out of order is O(n) because the underlying reader has to restart from the beginning. Decoded pages are cached; call ReleaseCache(int) to free a decoded page's memory.

ImageEncodingParam: The format-specific save parameters for cv::imwrite and cv::imencode

KalmanFilter: Kalman filter. The class implements standard Kalman filter \url{http://en.wikipedia.org/wiki/Kalman_filter}. However, you can modify KalmanFilter::transitionMatrix, KalmanFilter::controlMatrix and KalmanFilter::measurementMatrix to get the extended Kalman filter functionality.

KeyPointsFilter: A class filters a vector of keypoints.

LDA: Base class for objects that own a single native OpenCV pointer through an OpenCvSafeHandle. The SafeHandle is the single source of truth for the native handle value and is responsible for releasing it (including from its own finalizer when the managed object is dropped without Dispose()).

LightGlueMatcher: LightGlue: a deep learning based descriptor matcher with an attention mechanism (OpenCV 5). Runs an ONNX model through the DNN module. Requires OpenCV built with the dnn module.

Line2D: 2-dimentional line vector

Line3D: A 3-dimensional line object

LineIterator: Iterates over the pixels that lie on a line segment of an image, mirroring cv::LineIterator. The instance describes the scan (its length is available through Count immediately after construction); enumerating it walks the pixels from pt1 to pt2.

LineSegmentDetector: Line segment detector class

MSER: Maximal Stable Extremal Regions class

Mat: OpenCV C++ n-dimensional dense array class (cv::Mat)

Mat.Indexer<T>: Mat Indexer

Mat.UnsafeIndexer<T>: Mat Indexer

MatExpr: A purely managed, lazily-evaluated matrix expression — the result of Mat arithmetic. This is the managed counterpart of OpenCV's cv::MatExpr (issue #1974).

MatIndexer<T>: Abstract definition of Mat indexer

MatMemoryManager<T>: A MemoryManager over an OpenCvSharpMat

MatSafeHandle: A OpenCvSafeHandle that releases a native cv::Mat* pointer.

Mat<TElem>: Type-specific matrix. TElem fixes the element type, so elements can be read and written as TElem (e.g. via mat[row, col]) and the matrix can be enumerated.

Mat<TElem>.Indexer: Matrix indexer

MergeDebevec

The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response.

For more information see @cite DM97 .

MergeExposures: The base class algorithms that can merge exposure sequence to a single image.

MergeMertens

Pixels are weighted using contrast, saturation and well-exposedness measures, than images are combined using laplacian pyramids.

The resulting image weight is constructed as weighted average of contrast, saturation and well-exposedness measures.

The resulting image doesn't require tonemapping and can be converted to 8-bit image by multiplying by 255, but it's recommended to apply gamma correction and/or linear tonemapping.

For more information see @cite MK07 .

Moments: Raster image moments

NormHistogramCostExtractor: A norm-based histogram cost extractor.

ORB

Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor.

described in @cite RRKB11 . The algorithm uses FAST in pyramids to detect stable keypoints, selects the strongest features using FAST or Harris response, finds their orientation using first-order moments and computes the descriptors using BRIEF (where the coordinates of random point pairs (or k-tuples) are rotated according to the measured orientation).

Odometry: Odometry algorithm that computes the rigid transformation between two frames.

OdometryFrame: An object that keeps per-frame data for Odometry algorithms.

OdometrySettings: Settings for the Odometry algorithm.

OpenCVException: The default exception to be thrown by OpenCV

OpenCvSafeHandle: Base class for SafeHandle instances wrapping native OpenCV pointers. Provides a common SafeHandle implementation where IntPtr.Zero is the invalid handle value.

OpenCvSharpException: The exception that is thrown by OpenCvSharp.

PCA: Principal Component Analysis

PyrLKOpticalFlow

QRCodeDetector

QRCodeDetectorAruco: QR code detector that uses the Aruco-based marker detector for locating the finder patterns.

QRCodeEncoder: QR code encoder

RegionGrowing3D: Region Growing algorithm in 3D point cloud.

RgbdNormals: Object that can compute the normals in an image. It is an object as it can cache data for speed efficiency.

RidgeDetectionFilter

Applies Ridge Detection Filter to an input image.

Implements Ridge detection similar to the one in Mathematica using the eigen values from the Hessian Matrix of the input image using Sobel Derivatives. Additional refinement can be done using Skeletonization and Binarization. Adapted from @cite segleafvein and @cite M_RF

SACSegmentation: Sample Consensus algorithm segmentation of 3D point cloud model.

SIFT: SIFT implementation.

SVD: Singular Value Decomposition class

ShapeContextDistanceExtractor: Implementation of the Shape Context descriptor and matching algorithm

ShapeDistanceExtractor: Abstract base class for shape distance algorithms.

ShapeTransformer: Abstract base class for shape transformation algorithms.

SimilarRects: Class for grouping object candidates, detected by Cascade Classifier, HOG etc. instance of the class is to be passed to cv::partition (see cxoperations.hpp)

SimpleBlobDetector: Class for extracting blobs from an image.

SimpleBlobDetector.Params: SimpleBlobDetector parameters

SparseMat: Sparse matrix (cv::SparseMat). This type-erased base exposes the structural and metadata operations that do not depend on the element type. For typed element access use SparseMat<T> (e.g. via As<T>()).

SparseMat<T>: Strongly-typed sparse matrix. T determines the element type, so element access needs no per-call type argument and no runtime type checks: reading an absent element returns default without creating it; assigning through the indexer creates it.

StereoBM: Semi-Global Stereo Matching

StereoMatcher: The base class for stereo correspondence algorithms.

StereoSGBM: Semi-Global Stereo Matching

Stitcher: High level image stitcher. It's possible to use this class without being aware of the entire stitching pipeline. However, to be able to achieve higher stitching stability and quality of the final images at least being familiar with the theory is recommended

Subdiv2D: Planar Subdivision

SuperResolution: Base class for Super Resolution algorithms.

SyntheticSequenceGenerator: Synthetic frame sequence generator for testing background subtraction algorithms. It will generate the moving object on top of the background. It will apply some distortion to the background to make the test more complex.

TextDetector: An abstract class providing interface for text detection algorithms

TextDetectorCNN: TextDetectorCNN class provides the functionality of text bounding box detection.

ThinPlateSplineShapeTransformer: Thin Plate Spline shape transformer.

Tonemap: Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range.

TonemapDrago

Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in logarithmic domain.

Since it's a global operator the same function is applied to all the pixels, it is controlled by the bias parameter. Optional saturation enhancement is possible as described in @cite FL02. For more information see @cite DM03.

TonemapMantiuk

This algorithm transforms image to contrast using gradients on all levels of gaussian pyramid, transforms contrast values to HVS response and scales the response. After this the image is reconstructed from new contrast values.

For more information see @cite MM06.

TonemapReinhard

This is a global tonemapping operator that models human visual system.

Mapping function is controlled by adaptation parameter, that is computed using light adaptation and color adaptation. For more information see @cite RD05.

Tracker: Base abstract class for the long-term tracker

TrackerMIL: Base abstract class for the long-term tracker

UMat: OpenCV C++ n-dimensional dense array class (cv::Mat)

UsacParams

VideoCapture: Video capturing class

VideoCapturePara: Parameters of VideoCapture for hardware acceleration Please check the link below for current HW acceleration types support matrix https://github.com/opencv/opencv/wiki/Video-IO-hardware-acceleration

VideoWriter: AVI Video File Writer

VideoWriterPara: Parameters of VideoWriter for hardware acceleration Please check the link below for current HW acceleration types support matrix https://github.com/opencv/opencv/wiki/Video-IO-hardware-acceleration

Volume: Custom volume (TSDF, HashTSDF or ColorTSDF) for point cloud integration and raycasting.

VolumeSettings: Settings for a TSDF/HashTSDF/ColorTSDF Volume.

WeChatQRCode: 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.

Window: Wrapper of HighGUI window

Structs

CircleSegment: circle structure retrieved from cvHoughCircle

CirclesGridFinderParameters: Parameters for the findCirclesGrid process (cv::CirclesGridFinderParameters).

DMatch: Struct for matching: query descriptor index, train descriptor index, train image index and distance between descriptors.

FourCC: 4-character code of codec used to compress the frames.

InputArray: Stack-only input proxy (see file header). Carries a native handle or an inline value; building one allocates nothing on the managed heap.

InputOutputArray: Stack-only input/output proxy (see file header). Single Mat/UMat only; its read/write role is flag-dependent in OpenCV, so it is kept as one type (not split into in/out variants).

KeyPoint: Data structure for salient point detectors

LineIterator.Pixel: LineIterator pixel data: its position and a pointer into the image buffer.

LineSegmentPoint: Line segment structure retrieved from cvHoughLines2

LineSegmentPolar: Polar line segment retrieved from cvHoughLines2

MSTEdge: Represents an edge in a graph for Minimum Spanning Tree (MST) computation. See BuildMST(int, MSTEdge[], MSTAlgorithm, int).

MatRowAccessor<T>: Provides zero-allocation, zero-P/Invoke-per-element row access to a 2D Mat. Obtain via AsRows<T>(). The data pointer, step, and dimensions are captured once at construction time, so all subsequent row indexing is pure pointer arithmetic.

MatShape: Represents the shape of a matrix / tensor (OpenCV 5, cv::MatShape). In addition to the per-axis sizes it carries the data Layout and, for the block layout, the actual number of Channels (C). It also distinguishes an empty shape (IsEmpty, total == 0) from a 0-dimensional scalar shape (IsScalar, dims == 0 but total == 1).

MatType: Matrix data type (depth and number of channels)

Moments.NativeStruct

OutputArray: Stack-only output proxy (see file header). Single Mat/UMat output only — native writes through the referenced matrix directly, so no write-back (Fix/AssignResult) is needed.

Point

Point2d: ///

Point2f

Point3d: ///

Point3f: ///

Point3i

QRCodeDetectorArucoParams: Parameters for the QRCodeDetectorAruco (cv::QRCodeDetectorAruco::Params).

QRCodeEncoderParams: Parameters for the QRCodeEncoder (cv::QRCodeEncoder::Params).

RNG: Random Number Generator. The class implements RNG using Multiply-with-Carry algorithm.

RNG_MT19937: Mersenne Twister random number generator

Range: Template class specifying a continuous subsequence (slice) of a sequence.

Rangef: float Range class

Rect: Stores a set of four integers that represent the location and size of a rectangle

Rect2d: Stores a set of four double-precision floating-point numbers that represent the location and size of a rectangle

Rect2f: A rectangle with float type coordinates in 2D space

RotatedRect: The class represents rotated (i.e. not up-right) rectangles on a plane.

Scalar: Template class for a 4-element vector derived from Vec.

SimpleBlobDetector.WParams

Size

Size2d

Size2f

TermCriteria: The class defining termination criteria for iterative algorithms.

TrackerMIL.Params

Vec2b: 2-Tuple of byte (System.Byte)

Vec2d: 2-Tuple of double (System.Double)

Vec2f: 2-Tuple of float (System.Single)

Vec2i: 2-Tuple of int (System.Int32)

Vec2s: 2-Tuple of short (System.Int16)

Vec2w: 2-Tuple of ushort (System.UInt16)

Vec3b: 3-Tuple of byte (System.Byte)

Vec3d: 3-Tuple of double (System.Double)

Vec3f: 3-Tuple of float (System.Single)

Vec3i: 3-Tuple of int (System.Int32)

Vec3s: 3-Tuple of short (System.Int16)

Vec3w: 3-Tuple of ushort (System.UInt16)

Vec4b: 4-Tuple of byte (System.Byte)

Vec4d: 4-Tuple of double (System.Double)

Vec4f: 4-Tuple of float (System.Single)

Vec4i: 4-Tuple of int (System.Int32)

Vec4s: 4-Tuple of short (System.Int16)

Vec4w: 4-Tuple of ushort (System.UInt16)

Vec6b: 6-Tuple of byte (System.Byte)

Vec6d: 6-Tuple of double (System.Double)

Vec6f: 6-Tuple of float (System.Single)

Vec6i: 6-Tuple of int (System.Int32)

Vec6s: 6-Tuple of short (System.Int16)

Vec6w: 6-Tuple of ushort (System.UInt16)

WUsacParams

Interfaces

IStreamReader: Read data stream interface. Implement this to let VideoCapture read from an arbitrary managed data source (e.g. an in-memory buffer, network stream, or any other custom stream).

IVec: Vec empty interface

IVec<TSelf, TElem>: Vec** interface

Enums

AKAZEDescriptorType: cv::AKAZE descriptor type

ANNIndexDistance: Metrics used by ANNIndex to calculate the distance between two feature vectors.

AccessFlag: cv::AccessFlag

AdaptiveThresholdTypes: Adaptive thresholding algorithms

AlgorithmHint: Hint that selects between alternative algorithm implementations (OpenCV 5). Passed to functions such as warpAffine, warpPerspective, remap, GaussianBlur and cvtColor.

AlgorithmParamType: cv::Algorithm parameter type

ArrayProxyKind: Kind of array a proxy refers to. Must match the switch in my_types.h.

BeblidSize: Descriptor number of bits, each bit is a boosting weak-learner. cv::xfeatures2d::BEBLID::BeblidSize

BoostDescType: Descriptor type for cv::xfeatures2d::BoostDesc.

BorderTypes: Type of the border to create around the copied source image rectangle

ButtonType: Button type flags (cv::createButton)

CalibrationFlags: Different flags for cvCalibrateCamera2 and cvStereoCalibrate

CameraChannels: channel indices for multi-head camera live streams

CameraModel: Camera model used by the OpenCV 5 multi-view calibration functions (RegisterCameras(IEnumerable<Mat>, IEnumerable<Mat>, IEnumerable<Mat>, IEnumerable<Mat>, InputArray, InputArray, CameraModel, InputArray, InputArray, CameraModel, InputOutputArray, InputOutputArray, OutputArray, OutputArray, OutputArray, CalibrationFlags, TermCriteria?) / CalibrateMultiview(IEnumerable<Mat>, IReadOnlyList<IReadOnlyList<Mat>>, IEnumerable<Size>, InputArray, InputArray, out Mat[], out Mat[], out Mat[], out Mat[], InputArray, CalibrationFlags, TermCriteria?)).

CapturePosAviRatio: Position in relative units

CaptureType: Capture type of CvCapture (Camera or AVI file)

ChessboardFlags: Various operation flags for cvFindChessboardCorners

CirclesGridFinderGridType: Grid type used by CirclesGridFinderParameters (cv::CirclesGridFinderParameters::GridType).

CmpType: Obsolete: Use CmpTypes instead. This enum is kept for backward compatibility.

CmpTypes: The flag specifying the relation between the elements to be checked

ColorConversionCodes: Color conversion operation for cv::cvtColor

ColormapTypes: GNU Octave/MATLAB equivalent colormaps

ConnectedComponentsAlgorithmsTypes: connected components algorithm

ConnectedComponentsTypes: components algorithm output formats

ContourApproximationModes: Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation).

ConvertImageModes

CovarFlags: Operation flags for Covariation

CpuFeatures

CriteriaTypes: Type of termination criteria

DAISYNormalizationType: Descriptor normalization type for cv::xfeatures2d::DAISY.

DataLayout: Data layout of a matrix / tensor (OpenCV 5, cv::DataLayout). Defined in the core module and shared by core (MatShape) and dnn (e.g. blob-from-image parameters).

DctFlags: Transformation flags for cv::dct

DecompTypes: Inversion methods

DescriptorMatcher.MatcherType: Descriptor matcher type, mirroring cv::DescriptorMatcher::MatcherType.

DftFlags: Transformation flags for cvDFT

DistanceTransformLabelTypes: distanceTransform algorithm flags

DistanceTransformMasks: Mask size for distance transform

DistanceTypes: Type of distance for cvDistTransform

DistributionType: Distribution type for cvRandArr, etc.

DrawMatchesFlags

EMStartStep: The initial step the algorithm starts from

EMTypes: Type of covariation matrices

EdgePreservingMethods: Edge preserving filters

ErrorCode: Error status codes

EssentialMatMethod: Method for computing the essential matrix

FASTType: AGAST type one of the four neighborhoods as defined in the paper

FaceRecognizerSFDisType: Definition of distance used for calculating the distance between two face features (cv::FaceRecognizerSF::DisType).

FileNode.Types: type of the file storage node

FileStorage.Modes: File storage mode

FileStorage.States

FindCirclesGridFlags: Method for solving a PnP problem:

FishEyeCalibrationFlags

FlipMode: Specifies how to flip the array

FloodFillFlags: floodFill Operation flags. Lower bits contain a connectivity value, 4 (default) or 8, used within the function. Connectivity determines which neighbors of a pixel are considered. Upper bits can be 0 or a combination of the following flags:

FormatType: Output string format of Mat.Dump()

FundamentalMatMethods: Method for computing the fundamental matrix

GemmFlags: The operation flags for cv::GEMM

GrabCutClasses: class of the pixel in GrabCut algorithm

GrabCutModes: GrabCut algorithm flags

HaarDetectionTypes: Modes of operation for cvHaarDetectObjects

HandEyeCalibrationMethod: method One of the implemented Hand-Eye calibration method

HersheyFonts: Font name identifier. Only a subset of Hershey fonts (http://sources.isc.org/utils/misc/hershey-font.txt) are supported now.

HistCompMethods: Comparison methods for cvCompareHist

HistogramNormType: L2-Hys normalization method

HomographyMethods: The method used to computed homography matrix

HoughModes: Variants of a Hough transform

ImageMetadataType: Type of metadata chunk stored in / retrieved from an image file by the *WithMetadata family of functions.

ImreadModes: Specifies colorness and Depth of the loaded image

ImwriteBMPCompressionFlags: Imwrite BMP specific values for the IMWRITE_BMP_COMPRESSION parameter key.

ImwriteEXRCompressionFlags: Imwrite EXR specific values for the IMWRITE_EXR_COMPRESSION parameter key.

ImwriteEXRTypeFlags

ImwriteFlags: The format type IDs for cv::imwrite and cv::inencode

ImwriteGIFCompressionFlags: Imwrite GIF specific values for the IMWRITE_GIF_QUALITY parameter key. If larger than 3, it relates to the size of the color table.

ImwriteHDRCompressionFlags: Imwrite HDR specific values for the IMWRITE_HDR_COMPRESSION parameter key.

ImwriteJPEGSamplingFactorParams: Imwrite JPEG specific values for IMWRITE_JPEG_SAMPLING_FACTOR parameter key.

ImwritePAMFlags: Imwrite PAM specific tupletype flags used to define the 'TUPETYPE' field of a PAM file.

ImwritePNGFlags

Imwrite PNG specific flags used to tune the compression algorithm.

These flags will be modify the way of PNG image compression and will be passed to the underlying zlib processing stage. The effect of IMWRITE_PNG_StrategyFILTERED is to force more Huffman coding and less string matching; it is somewhat intermediate between IMWRITE_PNG_StrategyDEFAULT and IMWRITE_PNG_StrategyHUFFMAN_ONLY. IMWRITE_PNG_StrategyRLE is designed to be almost as fast as IMWRITE_PNG_StrategyHUFFMAN_ONLY, but give better compression for PNG image data. The strategy parameter only affects the compression ratio but not the correctness of the compressed output even if it is not set appropriately. IMWRITE_PNG_StrategyFIXED prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications.

ImwriteTiffCompressionFlags: Imwrite TIFF specific values for the IMWRITE_TIFF_COMPRESSION parameter key.

ImwriteTiffPredictorFlags: Imwrite TIFF specific values for the IMWRITE_TIFF_PREDICTOR parameter key.

ImwriteTiffResolutionUnitFlags: Imwrite TIFF specific values for the IMWRITE_TIFF_RESUNIT parameter key.

ImwriteWEBPLosslessMode: Imwrite WEBP specific values for the IMWRITE_WEBP_LOSSLESS_MODE parameter key.

InpaintMethod: Obsolete: Use InpaintTypes instead. This enum is kept for backward compatibility.

InpaintTypes: The inpainting method

InterpolationFlags: Interpolation algorithm

KAZEDiffusivityType: cv::KAZE diffusivity type

KMeansFlags: Miscellaneous flags for cv::kmeans

LSBPCameraMotionCompensation: cv::bgsegm::LSBPCameraMotionCompensation

LineSegmentDetectorModes: Variants of Line Segment %Detector

LineTypes: Type of the line

LocalOptimMethod

LogLevel: cv::utils::logging::LogLevel

MSTAlgorithm: Algorithms available for building a Minimum Spanning Tree (MST). See BuildMST(int, MSTEdge[], MSTAlgorithm, int).

MarkerTypes: Possible set of marker types used for the cv::drawMarker function

MatDiagType: diagonal type

MorphShapes: Shape of the structuring element

MorphTypes: Type of morphological operation

MotionTypes: [findTransformECC] specifying the type of motion

MouseEventFlags: Mouse Event Flags see cv::MouseCallback

MouseEventTypes: Mouse Events

NeighborSearchMethod

NextEdgeType: Parameter for Subdiv2D.GetEdge() specifying which of the related edges to return.

NormTypes: Type of norm

ORBScoreType: cv::ORB score flags

OdometryAlgoType: These constants are used to set the speed and accuracy of odometry.

OdometryFramePyramidType: Indicates what pyramid is to access using OdometryFrame.GetPyramidAt() method.

OdometryType: These constants are used to set a type of data which odometry will use.

OpticalFlowFlags: cv::calcOpticalFlowPyrLK flags

PCA.Flags: Flags for PCA operations

PCTSignaturesDistanceFunction: Lp distance function selector for cv::xfeatures2d::PCTSignatures.

PCTSignaturesPointDistribution: Point distributions supported by the random point generator of cv::xfeatures2d::PCTSignatures.

PCTSignaturesSimilarityFunction: Similarity function selector for cv::xfeatures2d::PCTSignatures.

PixelConnectivity: PixelConnectivity for LineIterator

PolishingMethod

ProjectionType: cv::initWideAngleProjMap flags

PutTextFlags: Flags for the FontFace-based PutText(InputOutputArray, string, Point, Scalar, FontFace, int, int, PutTextFlags, Range?) and GetTextSize(Size, string, Point, FontFace, int, int, PutTextFlags, Range?) (OpenCV 5).

QRCodeEncoderCorrectionLevel: cv::QRCodeEncoder::CorrectionLevel

QRCodeEncoderECIEncodings: cv::QRCodeEncoder::ECIEncodings

QRCodeEncoderMode: cv::QRCodeEncoder::EncodeMode

RectanglesIntersectTypes: types of intersection between rectangles

ReduceDimension: The dimension index along which the matrix is reduce.

ReduceTypes: The reduction operations for cvReduce

RetrievalModes: mode of the contour retrieval algorithm

RgbdNormalsMethod: Method used to compute surface normals from a depth image (cv::RgbdNormals::RgbdNormalsMethod).

RgbdPlaneMethod: The method to use to compute the planes in a depth image (cv::RgbdPlaneMethod).

RobotWorldHandEyeCalibrationMethod: One of the implemented Robot-World/Hand-Eye calibration method

RobustEstimationAlgorithms: type of the robust estimation algorithm

RotateFlags: an enum to specify how to rotate the array.

SVD.Flags: Operation flags for SVD

SacMethod: Type of the robust estimation algorithm used by SACSegmentation.

SacModelType: Type of the sample consensus model used by SACSegmentation.

SamplingMethod

ScoreMethod

SeamlessCloneFlags: SeamlessClone method

SeamlessCloneMethods: Obsolete: Use SeamlessCloneFlags instead. This enum is kept for backward compatibility.

ShapeMatchModes: Comparison methods for cv::matchShapes

SolveLPResult: return codes for cv::solveLP() function

SolvePnPFlags: Obsolete: Use SolvePnPMethod instead. This enum is kept for backward compatibility.

SolvePnPMethod: Method for solving a PnP problem:

SortFlags: Signals an error and raises the exception.

StereoRectificationFlags: The operation flags for cvStereoRectify

StereoSGBMMode

Stitcher.Mode

Stitcher.Status: Status code

TeblidSize: Descriptor number of bits, each bit is a box average difference. cv::xfeatures2d::TEBLID::TeblidSize

TemplateMatchModes: Specifies the way the template must be compared with image regions

ThresholdTypes: Thresholding type

UMatUsageFlags: cv::UMatUsageFlags

VGGDescriptorType: Descriptor type for cv::xfeatures2d::VGG.

VideoAccelerationType: Video Acceleration type Used as value in #CAP_PROP_HW_ACCELERATION and #VIDEOWRITER_PROP_HW_ACCELERATION note In case of FFmpeg backend, it translated to enum AVHWDeviceType (https://github.com/FFmpeg/FFmpeg/blob/master/libavutil/hwcontext.h)

VideoCaptureAPIs: Camera device types

VideoCaptureDC1394Mode: Modes of the IEEE 1394 controlling registers (can be: auto, manual, auto single push, absolute. Latter allowed with any other mode). Every feature can have only one mode turned on at a time.

VideoCaptureOBSensorDataType: OBSENSOR data given from image generator

VideoCaptureOBSensorGenerators: OBSENSOR stream generator

VideoCaptureOBSensorProperties: OBSENSOR properties

VideoCaptureProperties: Property identifiers for CvCapture

VideoWriterProperties: VideoWriter generic properties identifier.

VolumeBoundingBoxPrecision: Bounding box calculation precision used by Volume.GetBoundingBox().

VolumeType: Volume type used by VolumeSettings and Volume.

WarpPolarMode: Specify the polar mapping mode

WindowFlags: Flags for cv::namedWindow

WindowPropertyFlags: Property identifiers for cvGetWindowProperty/cvSetWindowProperty

Delegates

Cv2.PartitionPredicate<T>: Equivalence predicate (a boolean function of two arguments). The predicate returns true when the elements are certainly in the same class, and returns false if they may or may not be in the same class.