_InputArray

This is the proxy class for passing readonly input arrays into OpenCV functions

_IplImage

The IplImage is taken from the Intel Image Processing Library, in which the format is native

_OutputArray

This type is very similar to InputArray except that it is used for input/output and output function parameters

Affine3< T >

Affine transform

AffineTransformer

Wrapper class for the OpenCV Affine Transformation algorithm

AgastFeatureDetector

Wrapping class for feature detection using the AGAST method

AKAZE

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

Algorithm

This is a base class for all more or less complex algorithms in OpenCV

AlignExposures

The base class for algorithms that align images of the same scene with different exposures

AlignMTB

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

Allocator< _Tp >


ANN_MLP

Artificial Neural Networks  MultiLayer Perceptrons

Arrays

Wrapper for OpenGL ClientSide Vertex arrays

AutoBuffer< _Tp, fixed_size >

Automatically Allocated Buffer Class

BackgroundSubtractor

Base class for background/foreground segmentation

BackgroundSubtractorKNN

Knearest neigbours  based Background/Foreground Segmentation
Algorithm

BackgroundSubtractorMOG2

Gaussian Mixturebased Background/Foreground Segmentation
Algorithm

BestOf2NearestMatcher

Features matcher which finds two best matches for each feature and leaves the best one only if the ratio between descriptor distances is greater than the threshold match_conf

BFMatcher

Bruteforce descriptor matcher

Blender

Base class for all blenders

BlocksGainCompensator

Exposure compensator which tries to remove exposure related artifacts by adjusting image block intensities, see UES01 for details

Boost

Boosted tree classifier derived from
DTrees

BOWImgDescriptorExtractor

Class to compute an image descriptor using the *bag of visual words*

BOWKMeansTrainer

Kmeans based class to train visual vocabulary using the *bag of visual words* approach

BOWTrainer

Abstract base class for training the *bag of visual words* vocabulary from a set of descriptors

BRISK

Class implementing the
BRISK
keypoint detector and descriptor extractor, described in LCS11

Buffer

Smart pointer for OpenGL buffer object with reference counting

BundleAdjusterBase

Base class for all camera parameters refinement methods

BundleAdjusterRay

Implementation of the camera parameters refinement algorithm which minimizes sum of the distances between the rays passing through the camera center and a feature

BundleAdjusterReproj

Implementation of the camera parameters refinement algorithm which minimizes sum of the reprojection error squares

CalibrateCRF

The base class for camera response calibration algorithms

CalibrateDebevec

Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system

CalibrateRobertson

Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system

CameraParams

Describes camera parameters

CascadeClassifier

Cascade classifier class for object detection

ChiHistogramCostExtractor

An Chi based cost extraction

choose_policy< any >

Choosing the policy for an any type is illegal, but should never happen

CommandLineParser

Designed for command line parsing

Complex< _Tp >

A complex number class

CompositeIndex< Distance >

This index builds a kdtree index and a kmeans index and performs nearest neighbour search both indexes

CompositeIndexParams

Index parameters for the
CompositeIndex

ConjGradSolver

This class is used to perform the nonlinear nonconstrained minimization of a function with known gradient,

CvAttrList

List of attributes

CvBox2D


CvChainPtReader

Freeman chain reader state

CvConnectedComp

Connected component structure

CvConvexityDefect

Convexity defect

CvFileNode

Basic element of the file storage  scalar or collection:

CvFont

Font structure

CvHuMoments

Hu invariants

CvLineIterator

Line iterator state:

CvMat

Matrix elements are stored row by row

CvMatND


CvMoments

Spatial and central moments

CvNArrayIterator

Matrix iterator: used for nary operations on dense arrays

CvRect


CvScalar


CvStringHashNode

All the keys (names) of elements in the readed file storage are stored in the hash to speed up the lookup operations:

CvTermCriteria


CvType

Class for automatic module/RTTI data registration/unregistration

CvTypeInfo

Type information

CylindricalWarper

Cylindrical warper factory class

CylindricalWarper

Warper that maps an image onto the x\*x + z\*z = 1 cylinder

DataDepth< _Tp >

A helper class for
cv::DataType

DataType< _Tp >

Template "trait" class for OpenCV primitive data types

DataType< Matx< _Tp, m, n > >


DataType< Vec< _Tp, cn > >


DescriptorMatcher::DescriptorCollection

Class to work with descriptors from several images as with one merged matrix

DescriptorMatcher

Abstract base class for matching keypoint descriptors

DetectionROI

Struct for detection region of interest (ROI)

DeviceInfo

Class providing functionality for querying the specified GPU properties

DMatch

Class for matching keypoint descriptors

DownhillSolver

This class is used to perform the nonlinear nonconstrained minimization of a function,

DTrees

The class represents a single decision tree or a collection of decision trees

DualTVL1OpticalFlow

"Dual TV L1" Optical Flow
Algorithm

DynamicBitset

Class reimplementing the boost version of it This helps not depending on boost, it also does not do the bound checks and has a way to reset a block for speed

EM

The class implements the Expectation Maximization algorithm

EMDHistogramCostExtractor

An EMD based cost extraction

EMDL1HistogramCostExtractor

An EMDL1 based cost extraction

Estimator

Rotation estimator base class

EventAccessor

Class that enables getting cudaEvent_t from cuda::Event

Exception

Class passed to an error

ExposureCompensator

Base class for all exposure compensators

FastFeatureDetector

Wrapping class for feature detection using the FAST method

FastMarchingMethod

Describes the Fast Marching Method implementation

FeatherBlender

Simple blender which mixes images at its borders

Feature2D

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

FeaturesFinder

Feature finders base class

FeaturesMatcher

Feature matchers base class

FileNode

File Storage Node class

FileNodeIterator

Used to iterate through sequences and mappings

FileStorage

XML/YAML file storage class that encapsulates all the information necessary for writing or reading data to/from a file

FlannBasedMatcher

Flannbased descriptor matcher

Formatted


Formatter


MinProblemSolver::Function

Represents function being optimized

GainCompensator

Exposure compensator which tries to remove exposure related artifacts by adjusting image intensities, see BL07 and WJ10 for details

GeneralizedHough

Finds arbitrary template in the grayscale image using Generalized Hough Transform

GeneralizedHoughBallard

Ballard, D.H

GeneralizedHoughGuil

Guil, N., GonzálezLinares, J.M

GenericIndex< Distance >

The FLANN nearest neighbor index class

GFTTDetector

Wrapping class for feature detection using the goodFeaturesToTrack function

GpuMat

Base storage class for GPU memory with reference counting

GraphCutSeamFinder

Minimum graph cutbased seam estimator

GraphCutSeamFinderBase

Base class for all minimum graphcutbased seam estimators

Hamming< T >

Hamming
distance functor (pop count between two binary vectors, i.e

HammingLUT

Hamming
distance functor  counts the bit differences between two strings  useful for the Brief descriptor bit count of A exclusive XOR'ed with B

HausdorffDistanceExtractor

A simple Hausdorff distance measure between shapes defined by contours

SparseMat::Hdr

Sparse matrix header

Heap< T >

Priority Queue Implementation

HierarchicalClusteringIndex< Distance >

Hierarchical index

HistogramCostExtractor

Abstract base class for histogram cost algorithms

HomographyBasedEstimator

Homography based rotation estimator

HostMem

Class with reference counting wrapping special memory type allocation functions from CUDA

ImageFeatures

Structure containing image keypoints and descriptors

ImageMotionEstimatorBase

Base class for global 2D motion estimation methods which take frames as input

Index_< T >


IndexHeader

Structure representing the index header

KalmanFilter

Kalman filter class

KAZE

Class implementing the
KAZE
keypoint detector and descriptor extractor, described in ABD12

KDTreeIndex< Distance >

Randomized kdtree index

KDTreeSingleIndex< Distance >

Randomized kdtree index

KeyPoint

Data structure for salient point detectors

KeypointBasedMotionEstimator

Describes a global 2D motion estimation method which uses keypoints detection and optical flow for matching

KeyPointsFilter

A class filters a vector of keypoints

KMeansIndex< Distance >

Hierarchical kmeans index

KNearest

The class implements KNearest Neighbors model

KNNRadiusUniqueResultSet< DistanceType >

Class that holds the k NN neighbors within a radius distance

KNNResultSet< DistanceType >

KNearest neighbour result set

KNNSimpleResultSet< DistanceType >

KNNSimpleResultSet
does not ensure that the element it holds are unique

KNNUniqueResultSet< DistanceType >

Class that holds the k NN neighbors Faster than
KNNResultSet
as it uses a binary heap and does not maintain two arrays

L2< T >

Squared Euclidean distance functor, optimized version

L2_Simple< T >

Squared Euclidean distance functor

LDA

Linear Discriminant Analysis

LineIterator

Line iterator

LineSegmentDetector

Line segment detector class

LogisticRegression

Implements Logistic Regression classifier

LshIndex< Distance >

Randomized kdtree index

LshStats

POD for stats about an LSH table

LshTable< ElementType >

Lsh hash table

Mat

Ndimensional dense array class

Mat_< _Tp >

Template matrix class derived from
Mat

MatAllocator

Custom array allocator

MatchesInfo

Structure containing information about matches between two images

MatCommaInitializer_< _Tp >

Commaseparated Matrix Initializer

MatConstIterator_< _Tp >

Matrix readonly iterator

MatExpr

Matrix expression representation

MatIterator_< _Tp >

Matrix readwrite iterator

Matrix< T >

Class that implements a simple rectangular matrix stored in a memory buffer and provides convenient matrixlike access using the [] operators

Matx< _Tp, m, n >

Template class for small matrices whose type and size are known at compilation time

MatxCommaInitializer< _Tp, m, n >

Commaseparated Matrix Initializer

MergeDebevec

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

MergeExposures

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

MergeMertens

Pixels are weighted using contrast, saturation and wellexposedness measures, than images are combined using laplacian pyramids

MergeRobertson

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

MinProblemSolver

Basic interface for all solvers

Moments

Struct returned by cv::moments

MotionEstimatorBase

Base class for all global motion estimation methods

MotionEstimatorL1

Describes a global 2D motion estimation method which minimizes L1 error

MotionEstimatorRansacL2

Describes a robust RANSACbased global 2D motion estimation method which minimizes L2 error

MSER

Maximally stable extremal region extractor

MultiBandBlender

Blender
which uses multiband blending algorithm (see BA83)

NAryMatIterator

Nary multidimensional array iterator

NNIndex< Distance >

Nearestneighbour index base class

SparseMat::Node

Sparse matrix node  element of a hash table

DTrees::Node

The class represents a decision tree node

NoExposureCompensator

Stub exposure compensator which does nothing

NormalBayesClassifier

Bayes classifier for normally distributed data

NormHistogramCostExtractor

A norm based cost extraction

NoSeamFinder

Stub seam estimator which does nothing

ORB

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

OrbFeaturesFinder

ORB
features finder

PairwiseSeamFinder

Base class for all pairwise seam estimators

ParallelLoopBody

Base class for parallel data processors

ParamGrid

The structure represents the logarithmic grid range of statmodel parameters

PCA

Principal Component Analysis

PlaneWarper

Plane warper factory class

PlaneWarper

Warper that maps an image onto the z = 1 plane

Point3_< _Tp >

Template class for 3D points specified by its coordinates `x`, `y` and `z`

Point_< _Tp >

Template class for 2D points specified by its coordinates `x` and `y`

ProjectorBase

Base class for warping logic implementation

Ptr< T >

Template class for smart pointers with shared ownership

QtFont

QtFont
available only for Qt

RadiusResultSet< DistanceType >

A resultset class used when performing a radius based search

RadiusUniqueResultSet< DistanceType >

Class that holds the radius nearest neighbors It is more accurate than RadiusResult as it is not limited in the number of neighbors

Range

Template class specifying a continuous subsequence (slice) of a sequence

RansacParams

Describes RANSAC method parameters

Rect_< _Tp >

Template class for 2D rectangles

RNG

Random Number Generator

RNG_MT19937

Mersenne Twister random number generator

RotatedRect

The class represents rotated (i.e

RotationWarper

Rotationonly model image warper interface

RotationWarperBase< P >

Base class for rotationbased warper using a detail::ProjectorBase_ derived class

RTrees

The class implements the random forest predictor

SavedIndexParams

(Deprecated) Index parameters for creating a saved index

Scalar_< _Tp >

Template class for a 4element vector derived from
Vec

SeamFinder

Base class for a seam estimator

Seq< _Tp >


SeqIterator< _Tp >


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

SimpleBlobDetector

Class for extracting blobs from an image

Size_< _Tp >

Template class for specifying the size of an image or rectangle

SparseMat

The class
SparseMat
represents multidimensional sparse numerical arrays

SparseMat_< _Tp >

Template sparse ndimensional array class derived from
SparseMat

SparseMatConstIterator

ReadOnly Sparse Matrix Iterator

SparseMatConstIterator_< _Tp >

Template ReadOnly Sparse Matrix Iterator Class

SparseMatIterator

Readwrite Sparse Matrix Iterator

SparseMatIterator_< _Tp >

Template ReadWrite Sparse Matrix Iterator Class

SphericalWarper

Spherical warper factory class

SphericalWarper

Warper that maps an image onto the unit sphere located at the origin

DTrees::Split

The class represents split in a decision tree

StartStopTimer

A startstop timer class

StatModel

Base class for statistical models in OpenCV ML

StereoBM

Class for computing stereo correspondence using the block matching algorithm, introduced and contributed to OpenCV by K

StereoMatcher

The base class for stereo correspondence algorithms

StereoSGBM

The class implements the modified H

Stitcher

High level image stitcher

Stream

This class encapsulates a queue of asynchronous calls

StreamAccessor

Class that enables getting cudaStream_t from
cuda::Stream

SuperResolution

Base class for Super Resolution algorithms

SurfFeaturesFinder

SURF features finder

SVD

Singular Value Decomposition

SVM

Support Vector Machines

TargetArchs

Class providing a set of static methods to check what NVIDIA\* card architecture the CUDA module was built for

TermCriteria

The class defining termination criteria for iterative algorithms

Texture2D

Smart pointer for OpenGL 2D texture memory with reference counting

ThinPlateSplineShapeTransformer

Definition of the transformation

Tonemap

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

TonemapDrago

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

TonemapDurand

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

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

TonemapReinhard

This is a global tonemapping operator that models human visual system

TrainData

Class encapsulating training data

UMat


UniqueRandom

Random number generator that returns a distinct number from the [0,n) interval each time

UniqueResultSet< DistanceType >

Class that holds the k NN neighbors Faster than
KNNResultSet
as it uses a binary heap and does not maintain two arrays

Vec< _Tp, cn >

Template class for short numerical vectors, a partial case of
Matx

VecCommaInitializer< _Tp, m >

Commaseparated
Vec
Initializer

VideoCapture

Class for video capturing from video files, image sequences or cameras

VideoWriter

Video writer class

VoronoiSeamFinder

Voronoi diagrambased seam estimator

WarperCreator

Image warper factories base class

WImage< T >

Image class which provides a thin layer around an IplImage

WImageBuffer< T >

Image class which owns the data, so it can be allocated and is always freed

WImageBufferC< T, C >

Like a
WImageBuffer
class but when the number of channels is known at compile time

WImageC< T, C >

Image class when both the pixel type and number of channels are known at compile time

WImageView< T >

View into an image class which allows treating a subimage as an image or treating external data as an image
