Namespace OpenCvSharp

Classes

AKAZE: Class implementing the AKAZE keypoint detector and descriptor extractor, described in @cite ANB13

AgastFeatureDetector: Detects corners using the AGAST algorithm

Algorithm: Base class for high-level OpenCV algorithms

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.

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

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

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

BRISK: BRISK implementation

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.

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.

BackgroundSubtractorKNN: K nearest neigbours algorithm

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.

ConnectedComponents: connected components that is returned from Cv2.ConnectedComponentsEx

ConnectedComponents.Blob: One blob

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

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

CvObject: A class which has a pointer of OpenCV structure

CvTrackbar: Trackbar that is shown on OpenCV Window

DenseOpticalFlowExt: Base class for high-level OpenCV algorithms

DescriptorMatcher

DetectionROI: struct for detection region of interest (ROI)

DisposableCvObject: DisposableObject + ICvPtrHolder

DisposableObject: Represents a class which manages its own memory.

DualTVL1OpticalFlow

EM: The class implements the Expectation Maximization algorithm.

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: DisposableObject + ICvPtrHolder

FileStorage: XML/YAML File Storage Class.

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.

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

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

InputArray: Proxy data type for passing Mat's and vector<>'s as input parameters

InputOutputArray: Proxy data type for passing Mat's and vector<>'s as input parameters. Synonym for OutputArray.

KAZE: Class implementing the KAZE keypoint detector and descriptor extractor

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: DisposableObject + ICvPtrHolder

Line2D: 2-dimentional line vector

Line3D: A 3-dimensional line object

LineIterator: Contrast Limited Adaptive Histogram Equalization

LineIterator.Pixel: LineIterator pixel data

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: Matrix expression

MatExprRowColIndexer

MatIndexer<T>: Abstract definition of Mat indexer

MatMemoryManager<T>: A MemoryManager over an OpenCvSharpMat

Mat<TElem>: Type-specific abstract matrix

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

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).

OpenCVException: The default exception to be thrown by OpenCV

OpenCvSharpException: The exception that is thrown by OpenCvSharp.

OutputArray: Proxy datatype for passing Mat's and List<>'s as output parameters

OutputArrayOfMatList: Proxy datatype for passing Mat's and List<>'s as output parameters

OutputArrayOfStructList<T>: Proxy datatype for passing Mat's and List<>'s as output parameters

PCA: Principal Component Analysis

Ptr: Template class for smart reference-counting pointers

PyrLKOpticalFlow

QRCodeDetector

ResourcesTracker: Used for managing the resources of OpenCVSharp, like Mat, MatExpr, etc.

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

SVD: Singular Value Decomposition class

ShapeContextDistanceExtractor: Implementation of the Shape Context descriptor and matching algorithm

ShapeDistanceExtractor: Abstract base class for shape distance 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 class.

SparseMat.Indexer<T>: Mat Indexer

SparseMatIndexer<T>: Abstract definition of Mat indexer

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.

TextDetector: An abstract class providing interface for text detection algorithms

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

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

TrackerGOTURN: 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

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

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.

KeyPoint: Data structure for salient point detectors

LineSegmentPoint: Line segment structure retrieved from cvHoughLines2

LineSegmentPolar: Polar line segment retrieved from cvHoughLines2

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

Moments.NativeStruct

Point

Point2d: ///

Point2f

Point3d: ///

Point3f: ///

Point3i

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.

TrackerGOTURN.Params

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: 4-Tuple of ushort (System.UInt16)

WUsacParams

Interfaces

ICvPtrHolder: Represents a OpenCV-based class which has a native pointer.

IVec: Vec empty interface

IVec<TSelf, TElem>: Vec** interface

Enums

AKAZEDescriptorType: cv::AKAZE descriptor type

AccessFlag: cv::AccessFlag

AdaptiveThresholdTypes: Adaptive thresholding algorithms

AgastFeatureDetector.DetectorType: AGAST type one of the four neighborhoods as defined in the paper

AlgorithmParamType: cv::Algorithm parameter type

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

CapturePosAviRatio: Position in relative units

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

ChessboardFlags: Various operation flags for cvFindChessboardCorners

CmpType: 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

DctFlags: Transformation flags for cv::dct

DecompTypes: Inversion methods

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

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

ImreadModes: Specifies colorness and Depth of the loaded image

ImwriteEXRTypeFlags

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

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.

InOutArrayKind

InpaintMethod: The inpainting method

InterpolationFlags: Interpolation algorithm

KAZEDiffusivityType: cv::KAZE diffusivity type

KMeansFlags: Miscellaneous flags for cv::kmeans

LineSegmentDetectorModes: Variants of Line Segment %Detector

LineTypes: Type of the line

LocalOptimMethod

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

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

OpticalFlowFlags: cv::calcOpticalFlowPyrLK flags

PCA.Flags: Flags for PCA operations

PixelConnectivity: PixelConnectivity for LineIterator

ProjectionType: cv::initWideAngleProjMap flags

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

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

SamplingMethod

ScoreMethod

SeamlessCloneMethods: SeamlessClone method

ShapeMatchModes: Comparison methods for cv::matchShapes

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

SolvePnPFlags: 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

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

ThresholdTypes: Thresholding type

UMatUsageFlags: cv::UMatUsageFlags

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

VideoCaptureProperties: Property identifiers for CvCapture

VideoWriterProperties: VideoWriter generic properties identifier.

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.