Classes

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

AKAZE descriptors can only be used with KAZE or AKAZE keypoints. This class is thread-safe.

Member of Features2d

Artificial Neural Networks - Multi-Layer Perceptrons.

Unlike many other models in ML that are constructed and trained at once, in the MLP model these steps are separated. First, a network with the specified topology is created using the non-default constructor or the method ANN_MLP::create. All the weights are set to zeros. Then, the network is trained using a set of input and output vectors. The training procedure can be repeated more than once, that is, the weights can be adjusted based on the new training data.

Additional flags for StatModel::train are available: ANN_MLP::TrainFlags.

Member of Ml

Interface for Adaptive Manifold Filter realizations.

For more details about this filter see CITE: Gastal12 and References_.

Below listed optional parameters which may be set up with Algorithm::set function.

• member double sigma_s = 16.0 Spatial standard deviation.
• member double sigma_r = 0.2 Color space standard deviation.
• member int tree_height = -1 Height of the manifold tree (default = -1 : automatically computed).
• member int num_pca_iterations = 1 Number of iterations to computed the eigenvector.
• member bool adjust_outliers = false Specify adjust outliers using Eq. 9 or not.
• member bool use_RNG = true Specify use random number generator to compute eigenvector or not.

Member of Ximgproc

Wrapping class for feature detection using the AGAST method. :

Member of Features2d

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

especially for classes of algorithms, for which there can be multiple implementations. The examples are stereo correspondence (for which there are algorithms like block matching, semi-global block matching, graph-cut etc.), background subtraction (which can be done using mixture-of-gaussians models, codebook-based algorithm etc.), optical flow (block matching, Lucas-Kanade, Horn-Schunck etc.).

Here is example of SimpleBlobDetector use in your application via Algorithm interface: SNIPPET: snippets/core_various.cpp Algorithm

Member of Core

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

Member of Photo

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.

It is invariant to exposure, so exposure values and camera response are not necessary.

In this implementation new image regions are filled with zeros.

For more information see CITE: GW03 .

Member of Photo

The Aruco module

Member classes: DetectorParameters, Board, GridBoard, Dictionary, CharucoBoard

Member enums: CornerRefineMethod, PREDEFINED_DICTIONARY_NAME

Computes average hash value of the input image

This is a fast image hashing algorithm, but only work on simple case. For more details, please refer to CITE: lookslikeit

Member of Img_hash

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. This descriptor matcher supports masking permissible matches of descriptor sets.

Member of Features2d

Implementation of bio-inspired features (BIF) from the paper: Guo, Guodong, et al. “Human age estimation using bio-inspired features.” Computer Vision and Pattern Recognition, 2009. CVPR 2009.

Member of Face

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

Such a computation consists of the following steps:

1. Compute descriptors for a given image and its keypoints set.
2. Find the nearest visual words from the vocabulary for each keypoint descriptor.
3. Compute the bag-of-words image descriptor as is a normalized histogram of vocabulary words encountered in the image. The i-th bin of the histogram is a frequency of i-th word of the vocabulary in the given image.

Member of Features2d

kmeans -based class to train visual vocabulary using the bag of visual words approach. :

Member of Features2d

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

For details, see, for example, Visual Categorization with Bags of Keypoints by Gabriella Csurka, Christopher R. Dance, Lixin Fan, Jutta Willamowski, Cedric Bray, 2004. :

Member of Features2d

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

Member of Features2d

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.

Member of Video

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

%Algorithm by Sagi Zeevi ( https://github.com/sagi-z/BackgroundSubtractorCNT )

Member of Bgsegm

Background Subtractor module based on the algorithm given in CITE: Gold2012 .

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. This class implements an algorithm described in “Visual Tracking of Human Visitors under Variable-Lighting Conditions for a Responsive Audio Art Installation,” A. Godbehere, A. Matsukawa, K. Goldberg, American Control Conference, Montreal, June 2012.

Member of Bgsegm

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.

Member of Bgsegm

K-nearest neighbours - based Background/Foreground Segmentation Algorithm.

The class implements the K-nearest neighbours background subtraction described in CITE: Zivkovic2006 . Very efficient if number of foreground pixels is low.

Member of Video

Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016

Member of Bgsegm

This is for calculation of the LSBP descriptors.

Member of Bgsegm

Gaussian Mixture-based Background/Foreground Segmentation Algorithm.

The class implements the algorithm described in CITE: KB2001 .

Member of Bgsegm

Gaussian Mixture-based Background/Foreground Segmentation Algorithm.

The class implements the Gaussian mixture model background subtraction described in CITE: Zivkovic2004 and CITE: Zivkovic2006 .

Member of Video

The BaseCascadeClassifier module

Member of Objdetect

The BaseOCR module

Member of Text

The BasicFaceRecognizer module

Member of Face

The Bgsegm module

Member classes: BackgroundSubtractorMOG, BackgroundSubtractorGMG, BackgroundSubtractorCNT, BackgroundSubtractorGSOC, BackgroundSubtractorLSBP, BackgroundSubtractorLSBPDesc, SyntheticSequenceGenerator

Member enums: LSBPCameraMotionCompensation

The Bioinspired module

Member classes: TransientAreasSegmentationModule, Retina, RetinaFastToneMapping

Image hash based on block mean.

See CITE: zauner2010implementation for details.

Member of Img_hash

Board of markers

A board is a set of markers in the 3D space with a common coordinate system. The common form of a board of marker is a planar (2D) board, however any 3D layout can be used. A Board object is composed by:

• The object points of the marker corners, i.e. their coordinates respect to the board system.
• The dictionary which indicates the type of markers of the board
• The identifier of all the markers in the board.

Member of Aruco

Boosted tree classifier derived from DTrees

Member of Ml

Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in CITE: Trzcinski13a and CITE: Trzcinski13b.

desc type of descriptor to use, BoostDesc::BINBOOST_256 is default (256 bit long dimension) Available types are: BoostDesc::BGM, BoostDesc::BGM_HARD, BoostDesc::BGM_BILINEAR, BoostDesc::LBGM, BoostDesc::BINBOOST_64, BoostDesc::BINBOOST_128, BoostDesc::BINBOOST_256 use_orientation sample patterns using keypoints orientation, enabled by default scale_factor adjust the sampling window of detected keypoints 6.25f is default and fits for KAZE, SURF detected keypoints window ratio 6.75f should be the scale for SIFT detected keypoints window ratio 5.00f should be the scale for AKAZE, MSD, AGAST, FAST, BRISK keypoints window ratio 0.75f should be the scale for ORB keypoints ratio 1.50f was the default in original implementation

Member of Xfeatures2d

Class for computing BRIEF descriptors described in CITE: calon2010 .

bytes legth of the descriptor in bytes, valid values are: 16, 32 (default) or 64 . use_orientation sample patterns using keypoints orientation, disabled by default.

Member of Xfeatures2d

Utility class to wrap a std::vector<char>

Base class for Contrast Limited Adaptive Histogram Equalization.

Member of Imgproc

The Calib3d module

Member classes: CirclesGridFinderParameters, StereoMatcher, StereoBM, StereoSGBM

Member enums: SolvePnPMethod, HandEyeCalibrationMethod, GridType, UndistortTypes

The base class for camera response calibration algorithms.

Member of Photo

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.

For more information see CITE: DM97 .

Member of Photo

Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system. This algorithm uses all image pixels.

For more information see CITE: RB99 .

Member of Photo

Cascade classifier class for object detection.

Member of Objdetect

ChArUco board Specific class for ChArUco boards. A ChArUco board is a planar board where the markers are placed inside the white squares of a chessboard. The benefits of ChArUco boards is that they provide both, ArUco markers versatility and chessboard corner precision, which is important for calibration and pose estimation. This class also allows the easy creation and drawing of ChArUco boards.

Member of Aruco

The CirclesGridFinderParameters module

Member of Calib3d

This class represents high-level API for classification models.

ClassificationModel allows to set params for preprocessing input image. ClassificationModel creates net from file with trained weights and config, sets preprocessing input, runs forward pass and return top-1 prediction.

Member of Dnn

Image hash based on color moments.

See CITE: tang2012perceptual for details.

Member of Img_hash

Class for ContourFitting algorithms. ContourFitting match two contours

Member of Ximgproc

The Core module

Member classes: Algorithm, TickMeter

Member enums: Code, DecompTypes, NormTypes, CmpTypes, GemmFlags, DftFlags, BorderTypes, SortFlags, CovarFlags, KmeansFlags, ReduceTypes, RotateFlags, Flags, Flags, FormatType, Param

Utility functions for handling CvType values

Class implementing DAISY descriptor, described in CITE: Tola10

radius radius of the descriptor at the initial scale q_radius amount of radial range division quantity q_theta amount of angular range division quantity q_hist amount of gradient orientations range division quantity norm choose descriptors normalization type, where DAISY::NRM_NONE will not do any normalization (default), DAISY::NRM_PARTIAL mean that histograms are normalized independently for L2 norm equal to 1.0, DAISY::NRM_FULL mean that descriptors are normalized for L2 norm equal to 1.0, DAISY::NRM_SIFT mean that descriptors are normalized for L2 norm equal to 1.0 but no individual one is bigger than 0.154 as in SIFT H optional 3x3 homography matrix used to warp the grid of daisy but sampling keypoints remains unwarped on image interpolation switch to disable interpolation for speed improvement at minor quality loss use_orientation sample patterns using keypoints orientation, disabled by default.

Member of Xfeatures2d

DIS optical flow algorithm.

This class implements the Dense Inverse Search (DIS) optical flow algorithm. More details about the algorithm can be found at CITE: Kroeger2016 . Includes three presets with preselected parameters to provide reasonable trade-off between speed and quality. However, even the slowest preset is still relatively fast, use DeepFlow if you need better quality and don’t care about speed.

This implementation includes several additional features compared to the algorithm described in the paper, including spatial propagation of flow vectors (REF: getUseSpatialPropagation), as well as an option to utilize an initial flow approximation passed to REF: calc (which is, essentially, temporal propagation, if the previous frame’s flow field is passed).

Member of Video

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

Interface for realizations of Domain Transform filter.

For more details about this filter see CITE: Gastal11 .

Member of Ximgproc

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

The current public interface of the class allows user to train only a single decision tree, however the class is capable of storing multiple decision trees and using them for prediction (by summing responses or using a voting schemes), and the derived from DTrees classes (such as RTrees and Boost) use this capability to implement decision tree ensembles.

Member of Ml

Base class for dense optical flow algorithms

Member of Video

Abstract base class for matching keypoint descriptors.

It has two groups of match methods: for matching descriptors of an image with another image or with an image set.

Member of Features2d

This class represents high-level API for object detection networks.

DetectionModel allows to set params for preprocessing input image. DetectionModel creates net from file with trained weights and config, sets preprocessing input, runs forward pass and return result detections. For DetectionModel SSD, Faster R-CNN, YOLO topologies are supported.

Member of Dnn

Parameters for the detectMarker process:

• adaptiveThreshWinSizeMin: minimum window size for adaptive thresholding before finding contours (default 3).
• adaptiveThreshWinSizeMax: maximum window size for adaptive thresholding before finding contours (default 23).
• adaptiveThreshWinSizeStep: increments from adaptiveThreshWinSizeMin to adaptiveThreshWinSizeMax during the thresholding (default 10).
• adaptiveThreshConstant: constant for adaptive thresholding before finding contours (default 7)
• minMarkerPerimeterRate: determine minimum perimeter for marker contour to be detected. This is defined as a rate respect to the maximum dimension of the input image (default 0.03).
• maxMarkerPerimeterRate: determine maximum perimeter for marker contour to be detected. This is defined as a rate respect to the maximum dimension of the input image (default 4.0).
• polygonalApproxAccuracyRate: minimum accuracy during the polygonal approximation process to determine which contours are squares. (default 0.03)
• minCornerDistanceRate: minimum distance between corners for detected markers relative to its perimeter (default 0.05)
• minDistanceToBorder: minimum distance of any corner to the image border for detected markers (in pixels) (default 3)
• minMarkerDistanceRate: minimum mean distance beetween two marker corners to be considered similar, so that the smaller one is removed. The rate is relative to the smaller perimeter of the two markers (default 0.05).
• cornerRefinementMethod: corner refinement method. (CORNER_REFINE_NONE, no refinement. CORNER_REFINE_SUBPIX, do subpixel refinement. CORNER_REFINE_CONTOUR use contour-Points, CORNER_REFINE_APRILTAG use the AprilTag2 approach). (default CORNER_REFINE_NONE)
• cornerRefinementWinSize: window size for the corner refinement process (in pixels) (default 5).
• cornerRefinementMaxIterations: maximum number of iterations for stop criteria of the corner refinement process (default 30).
• cornerRefinementMinAccuracy: minimum error for the stop cristeria of the corner refinement process (default: 0.1)
• markerBorderBits: number of bits of the marker border, i.e. marker border width (default 1).
• perspectiveRemovePixelPerCell: number of bits (per dimension) for each cell of the marker when removing the perspective (default 4).
• perspectiveRemoveIgnoredMarginPerCell: width of the margin of pixels on each cell not considered for the determination of the cell bit. Represents the rate respect to the total size of the cell, i.e. perspectiveRemovePixelPerCell (default 0.13)
• maxErroneousBitsInBorderRate: maximum number of accepted erroneous bits in the border (i.e. number of allowed white bits in the border). Represented as a rate respect to the total number of bits per marker (default 0.35).
• minOtsuStdDev: minimun standard deviation in pixels values during the decodification step to apply Otsu thresholding (otherwise, all the bits are set to 0 or 1 depending on mean higher than 128 or not) (default 5.0)
• errorCorrectionRate error correction rate respect to the maximun error correction capability for each dictionary. (default 0.6).
• aprilTagMinClusterPixels: reject quads containing too few pixels. (default 5)
• aprilTagMaxNmaxima: how many corner candidates to consider when segmenting a group of pixels into a quad. (default 10)
• aprilTagCriticalRad: Reject quads where pairs of edges have angles that are close to straight or close to 180 degrees. Zero means that no quads are rejected. (In radians) (default 10*PI/180)
• aprilTagMaxLineFitMse: When fitting lines to the contours, what is the maximum mean squared error allowed? This is useful in rejecting contours that are far from being quad shaped; rejecting these quads “early” saves expensive decoding processing. (default 10.0)
• aprilTagMinWhiteBlackDiff: When we build our model of black & white pixels, we add an extra check that the white model must be (overall) brighter than the black model. How much brighter? (in pixel values, [0,255]). (default 5)
• aprilTagDeglitch: should the thresholded image be deglitched? Only useful for very noisy images. (default 0)
• aprilTagQuadDecimate: Detection of quads can be done on a lower-resolution image, improving speed at a cost of pose accuracy and a slight decrease in detection rate. Decoding the binary payload is still done at full resolution. (default 0.0)
• aprilTagQuadSigma: What Gaussian blur should be applied to the segmented image (used for quad detection?) Parameter is the standard deviation in pixels. Very noisy images benefit from non-zero values (e.g. 0.8). (default 0.0)
• detectInvertedMarker: to check if there is a white marker. In order to generate a “white” marker just invert a normal marker by using a tilde, ~markerImage. (default false)

Member of Aruco

This struct stores the scalar value (or array) of one of the following type: double, cv::String or int64. TODO: Maybe int64 is useless because double type exactly stores at least 2^52 integers.

Member of Dnn

Dictionary/Set of markers. It contains the inner codification

bytesList contains the marker codewords where

• bytesList.rows is the dictionary size
• each marker is encoded using nbytes = ceil(markerSize*markerSize/8.)
• each row contains all 4 rotations of the marker, so its length is 4*nbytes

bytesList.ptr(i)[k*nbytes + j] is then the j-th byte of i-th marker, in its k-th rotation.

Member of Aruco

Main interface for all disparity map filters.

Member of Ximgproc

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.

Member of Ximgproc

The Dnn module

Member classes: DictValue, Layer, Net, Model, ClassificationModel, KeypointsModel, SegmentationModel, DetectionModel

Member enums: Backend, Target

Simple wrapper for a vector of two double

Simple wrapper for a vector of three double

Utility class to wrap a std::vector<double>

The class implements the Expectation Maximization algorithm.

Member of Ml

Base class for 1st and 2nd stages of Neumann and Matas scene text detection algorithm CITE: Neumann12. :

Extracts the component tree (if needed) and filter the extremal regions (ER’s) by using a given classifier.

Member of Text

Callback with the classifier is made a class.

 By doing it we hide SVM, Boost etc. Developers can provide their own classifiers to the
 ERFilter algorithm.

Member of Text

Sparse match interpolation algorithm based on modified locally-weighted affine estimator from CITE: Revaud2015 and Fast Global Smoother as post-processing filter.

Member of Ximgproc

Class implementing EdgeBoxes algorithm from CITE: ZitnickECCV14edgeBoxes :

Member of Ximgproc

The EigenFaceRecognizer module

Member of Face

Class implementing the FREAK (Fast Retina Keypoint) keypoint descriptor, described in CITE: AOV12 .

The algorithm propose a novel keypoint descriptor inspired by the human visual system and more precisely the retina, coined Fast Retina Key- point (FREAK). A cascade of binary strings is computed by efficiently comparing image intensities over a retinal sampling pattern. FREAKs are in general faster to compute with lower memory load and also more robust than SIFT, SURF or BRISK. They are competitive alternatives to existing keypoints in particular for embedded applications.

@note - An example on how to use the FREAK descriptor can be found at opencv_source_code/samples/cpp/freak_demo.cpp

Member of Xfeatures2d

The Face module

Member classes: FaceRecognizer, Facemark, PredictCollector, StandardCollector, FacemarkKazemi, FacemarkAAM, BIF, MACE, FacemarkTrain, FacemarkLBF, BasicFaceRecognizer, EigenFaceRecognizer, FisherFaceRecognizer, LBPHFaceRecognizer

Abstract base class for all face recognition models

All face recognition models in OpenCV are derived from the abstract base class FaceRecognizer, which provides a unified access to all face recongition algorithms in OpenCV.

### Description

I’ll go a bit more into detail explaining FaceRecognizer, because it doesn’t look like a powerful interface at first sight. But: Every FaceRecognizer is an Algorithm, so you can easily get/set all model internals (if allowed by the implementation). Algorithm is a relatively new OpenCV concept, which is available since the 2.4 release. I suggest you take a look at its description.

Algorithm provides the following features for all derived classes:

• So called “virtual constructor”. That is, each Algorithm derivative is registered at program start and you can get the list of registered algorithms and create instance of a particular algorithm by its name (see Algorithm::create). If you plan to add your own algorithms, it is good practice to add a unique prefix to your algorithms to distinguish them from other algorithms.
• Setting/Retrieving algorithm parameters by name. If you used video capturing functionality from OpenCV highgui module, you are probably familar with cv::cvSetCaptureProperty, ocvcvGetCaptureProperty, VideoCapture::set and VideoCapture::get. Algorithm provides similar method where instead of integer id’s you specify the parameter names as text Strings. See Algorithm::set and Algorithm::get for details.
• Reading and writing parameters from/to XML or YAML files. Every Algorithm derivative can store all its parameters and then read them back. There is no need to re-implement it each time.

Moreover every FaceRecognizer supports the:

• Training of a FaceRecognizer with FaceRecognizer::train on a given set of images (your face database!).
• Prediction of a given sample image, that means a face. The image is given as a Mat.
• Loading/Saving the model state from/to a given XML or YAML.

• Setting/Getting labels info, that is stored as a string. String labels info is useful for keeping names of the recognized people.

Sometimes you run into the situation, when you want to apply a threshold on the prediction. A common scenario in face recognition is to tell, whether a face belongs to the training dataset or if it is unknown. You might wonder, why there’s no public API in FaceRecognizer to set the threshold for the prediction, but rest assured: It’s supported. It just means there’s no generic way in an abstract class to provide an interface for setting/getting the thresholds of every possible FaceRecognizer algorithm. The appropriate place to set the thresholds is in the constructor of the specific FaceRecognizer and since every FaceRecognizer is a Algorithm (see above), you can get/set the thresholds at runtime!

Here is an example of setting a threshold for the Eigenfaces method, when creating the model:

// Let’s say we want to keep 10 Eigenfaces and have a threshold value of 10.0 int num_components = 10; double threshold = 10.0; // Then if you want to have a cv::FaceRecognizer with a confidence threshold, // create the concrete implementation with the appropriate parameters: Ptr model = EigenFaceRecognizer::create(num_components, threshold);

Sometimes it’s impossible to train the model, just to experiment with threshold values. Thanks to Algorithm it’s possible to set internal model thresholds during runtime. Let’s see how we would set/get the prediction for the Eigenface model, we’ve created above:

// The following line reads the threshold from the Eigenfaces model: double current_threshold = model->getDouble(“threshold”); // And this line sets the threshold to 0.0: model->set(“threshold”, 0.0);

If you’ve set the threshold to 0.0 as we did above, then:

// Mat img = imread(“person1/3.jpg”, IMREAD_GRAYSCALE); // Get a prediction from the model. Note: We’ve set a threshold of 0.0 above, // since the distance is almost always larger than 0.0, you’ll get -1 as // label, which indicates, this face is unknown int predicted_label = model->predict(img); // …

is going to yield -1 as predicted label, which states this face is unknown.

### Getting the name of a FaceRecognizer

Since every FaceRecognizer is a Algorithm, you can use Algorithm::name to get the name of a FaceRecognizer:

// Create a FaceRecognizer: Ptr model = EigenFaceRecognizer::create(); // And here’s how to get its name: String name = model->name();

Member of Face

Abstract base class for all facemark models

To utilize this API in your program, please take a look at the REF: tutorial_table_of_content_facemark ### Description

Facemark is a base class which provides universal access to any specific facemark algorithm. Therefore, the users should declare a desired algorithm before they can use it in their application.

Here is an example on how to declare a facemark algorithm:

// Using Facemark in your code: Ptr facemark = createFacemarkLBF();

The typical pipeline for facemark detection is as follows:

• Load the trained model using Facemark::loadModel.
• Perform the fitting on an image via Facemark::fit.

Member of Face

The FacemarkAAM module

Member of Face

The FacemarkKazemi module

Member of Face

The FacemarkLBF module

Member of Face

Abstract base class for trainable facemark models

To utilize this API in your program, please take a look at the REF: tutorial_table_of_content_facemark ### Description

The AAM and LBF facemark models in OpenCV are derived from the abstract base class FacemarkTrain, which provides a unified access to those facemark algorithms in OpenCV.

Here is an example on how to declare facemark algorithm:

// Using Facemark in your code: Ptr facemark = FacemarkLBF::create();

The typical pipeline for facemark detection is listed as follows:

• (Non-mandatory) Set a user defined face detection using FacemarkTrain::setFaceDetector. The facemark algorithms are designed to fit the facial points into a face. Therefore, the face information should be provided to the facemark algorithm. Some algorithms might provides a default face recognition function. However, the users might prefer to use their own face detector to obtains the best possible detection result.
• (Non-mandatory) Training the model for a specific algorithm using FacemarkTrain::training. In this case, the model should be automatically saved by the algorithm. If the user already have a trained model, then this part can be omitted.
• Load the trained model using Facemark::loadModel.
• Perform the fitting via the Facemark::fit.

Member of Face

Class computing a dense optical flow using the Gunnar Farneback’s algorithm.

Member of Video

Interface for implementations of Fast Bilateral Solver.

For more details about this solver see CITE: BarronPoole2016 .

Member of Ximgproc

Wrapping class for feature detection using the FAST method. :

Member of Features2d

Interface for implementations of Fast Global Smoother filter.

For more details about this filter see CITE: Min2014 and CITE: Farbman2008 .

Member of Ximgproc

Class implementing the FLD (Fast Line Detector) algorithm described in CITE: Lee14 .

Member of Ximgproc

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

Member of Features2d

The Features2d module

Member classes: Feature2D, SIFT, BRISK, ORB, MSER, FastFeatureDetector, AgastFeatureDetector, GFTTDetector, SimpleBlobDetector, SimpleBlobDetectorParams, KAZE, AKAZE, DescriptorMatcher, BFMatcher, FlannBasedMatcher, BOWTrainer, BOWKMeansTrainer, BOWImgDescriptorExtractor

Member enums: ScoreType, FastDetectorType, AgastDetectorType, DiffusivityType, DescriptorType, MatcherType, DrawMatchesFlags

The FisherFaceRecognizer module

Member of Face

Flann-based descriptor matcher.

This matcher trains cv::flann::Index on a train descriptor collection and calls its nearest search methods to find the best matches. So, this matcher may be faster when matching a large train collection than the brute force matcher. FlannBasedMatcher does not support masking permissible matches of descriptor sets because flann::Index does not support this. :

Member of Features2d

Simple wrapper for a vector of four float

Simple wrapper for a vector of six float

Utility class to wrap a std::vector<float>

Wrapping class for feature detection using the goodFeaturesToTrack function. :

Member of Features2d

finds arbitrary template in the grayscale image using Generalized Hough Transform

Member of Imgproc

finds arbitrary template in the grayscale image using Generalized Hough Transform

Detects position only without translation and rotation CITE: Ballard1981 .

Member of Imgproc

finds arbitrary template in the grayscale image using Generalized Hough Transform

Detects position, translation and rotation CITE: Guil1999 .

Member of Imgproc

Graph Based Segmentation Algorithm. The class implements the algorithm described in CITE: PFF2004 .

Member of Ximgproc

Class implementing the Gray-code pattern, based on CITE: UNDERWORLD.

The generation of the pattern images is performed with Gray encoding using the traditional white and black colors.

The information about the two image axes x, y is encoded separately into two different pattern sequences. A projector P with resolution (P_res_x, P_res_y) will result in Ncols = log 2 (P_res_x) encoded pattern images representing the columns, and in Nrows = log 2 (P_res_y) encoded pattern images representing the rows. For example a projector with resolution 1024x768 will result in Ncols = 10 and Nrows = 10.

However, the generated pattern sequence consists of both regular color and color-inverted images: inverted pattern images are images with the same structure as the original but with inverted colors. This provides an effective method for easily determining the intensity value of each pixel when it is lit (highest value) and when it is not lit (lowest value). So for a a projector with resolution 1024x768, the number of pattern images will be Ncols * 2 + Nrows * 2 = 40.

Member of Structured_light

Gray-world white balance algorithm

This algorithm scales the values of pixels based on a gray-world assumption which states that the average of all channels should result in a gray image.

It adds a modification which thresholds pixels based on their saturation value and only uses pixels below the provided threshold in finding average pixel values.

Saturation is calculated using the following for a 3-channel RGB image per pixel I and is in the range [0, 1]:

A threshold of 1 means that all pixels are used to white-balance, while a threshold of 0 means no pixels are used. Lower thresholds are useful in white-balancing saturated images.

Currently supports images of type REF: CV_8UC3 and REF: CV_16UC3.

Member of Xphoto

Planar board with grid arrangement of markers More common type of board. All markers are placed in the same plane in a grid arrangement. The board can be drawn using drawPlanarBoard() function (- see: drawPlanarBoard)

Member of Aruco

Interface for realizations of Guided Filter.

For more details about this filter see CITE: Kaiming10 .

Member of Ximgproc

Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector.

the HOG descriptor algorithm introduced by Navneet Dalal and Bill Triggs CITE: Dalal2005 .

useful links:

https://hal.inria.fr/inria-00548512/document/

https://en.wikipedia.org/wiki/Histogram_of_oriented_gradients

https://software.intel.com/en-us/ipp-dev-reference-histogram-of-oriented-gradients-hog-descriptor

http://www.learnopencv.com/histogram-of-oriented-gradients

http://www.learnopencv.com/handwritten-digits-classification-an-opencv-c-python-tutorial

Member of Objdetect

Class implementing the Harris-Laplace feature detector as described in CITE: Mikolajczyk2004.

Member of Xfeatures2d

Class implementing two-dimensional phase unwrapping based on CITE: 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.

The wrapped phase map and the unwrapped result are stored in CV_32FC1 Mat.

Member of Phase_unwrapping

Parameters of phaseUnwrapping constructor.

width Phase map width. height Phase map height. histThresh Bins in the histogram are not of equal size. Default value is 3*pi*pi. The one before “histThresh” value are smaller. nbrOfSmallBins Number of bins between 0 and “histThresh”. Default value is 10. nbrOfLargeBins Number of bins between “histThresh” and 32*pi*pi (highest edge reliability value). Default value is 5.

Member of Phase_unwrapping

The base class for image hash algorithms

Member of Img_hash

The Img_hash module

Member classes: AverageHash, ColorMomentHash, RadialVarianceHash, PHash, ImgHashBase, MarrHildrethHash, BlockMeanHash

Member enums: BlockMeanHashMode

The Imgcodecs module

Member of Imgcodecs Member enums: ImreadModes, ImwriteFlags, ImwriteEXRTypeFlags, ImwritePNGFlags, ImwritePAMFlags

The Imgproc module

Member classes: GeneralizedHough, GeneralizedHoughBallard, GeneralizedHoughGuil, CLAHE, Subdiv2D, LineSegmentDetector

Member enums: SmoothMethod_c, MorphShapes_c, SpecialFilter, MorphTypes, MorphShapes, InterpolationFlags, WarpPolarMode, InterpolationMasks, DistanceTypes, DistanceTransformMasks, ThresholdTypes, AdaptiveThresholdTypes, GrabCutClasses, GrabCutModes, DistanceTransformLabelTypes, FloodFillFlags, ConnectedComponentsTypes, ConnectedComponentsAlgorithmsTypes, RetrievalModes, ContourApproximationModes, ShapeMatchModes, HoughModes, LineSegmentDetectorModes, HistCompMethods, ColorConversionCodes, RectanglesIntersectTypes, LineTypes, HersheyFonts, MarkerTypes, TemplateMatchModes, ColormapTypes

Simple wrapper for a vector of four int

Utility class to wrap a std::vector<int>

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

Member of Features2d

The class implements K-Nearest Neighbors model

Member of Ml

Kalman filter class.

The class implements a standard Kalman filter http://en.wikipedia.org/wiki/Kalman_filter, CITE: Welch95 . However, you can modify transitionMatrix, controlMatrix, and measurementMatrix to get an extended Kalman filter functionality.

Member of Video

Object representing a point feature found by one of many available keypoint detectors, such as Harris corner detector, FAST, StarDetector, SURF, SIFT etc.

This class represents high-level API for keypoints models

KeypointsModel allows to set params for preprocessing input image. KeypointsModel creates net from file with trained weights and config, sets preprocessing input, runs forward pass and returns the x and y coordinates of each detected keypoint

Member of Dnn

latch Class for computing the LATCH descriptor. If you find this code useful, please add a reference to the following paper in your work: Gil Levi and Tal Hassner, “LATCH: Learned Arrangements of Three Patch Codes”, arXiv preprint arXiv:1501.03719, 15 Jan. 2015

LATCH is a binary descriptor based on learned comparisons of triplets of image patches.

bytes is the size of the descriptor - can be 64, 32, 16, 8, 4, 2 or 1 rotationInvariance - whether or not the descriptor should compansate for orientation changes. half_ssd_size - the size of half of the mini-patches size. For example, if we would like to compare triplets of patches of size 7x7x then the half_ssd_size should be (7-1)/2 = 3. sigma - sigma value for GaussianBlur smoothing of the source image. Source image will be used without smoothing in case sigma value is 0.

Note: the descriptor can be coupled with any keypoint extractor. The only demand is that if you use set rotationInvariance = True then you will have to use an extractor which estimates the patch orientation (in degrees). Examples for such extractors are ORB and SIFT.

Note: a complete example can be found under /samples/cpp/tutorial_code/xfeatures2D/latch_match.cpp

Member of Xfeatures2d

The LBPHFaceRecognizer module

Member of Face

Class implementing the locally uniform comparison image descriptor, described in CITE: LUCID

An image descriptor that can be computed very fast, while being about as robust as, for example, SURF or BRIEF.

Member of Xfeatures2d

This interface class allows to build new Layers - are building blocks of networks.

Each class, derived from Layer, must implement allocate() methods to declare own outputs and forward() to compute outputs. Also before using the new layer into networks you must register your layer by using one of REF: dnnLayerFactory “LayerFactory” macros.

Member of Dnn

More sophisticated learning-based automatic white balance algorithm.

As REF: GrayworldWB, this algorithm works by applying different gains to the input image channels, but their computation is a bit more involved compared to the simple gray-world assumption. More details about the algorithm can be found in CITE: Cheng2015 .

To mask out saturated pixels this function uses only pixels that satisfy the following condition:

Currently supports images of type REF: CV_8UC3 and REF: CV_16UC3.

Member of Xphoto

Line segment detector class

following the algorithm described at CITE: Rafael12 .

Member of Imgproc

Implements Logistic Regression classifier.

Member of Ml

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)

 see also: CITE: Savvides04

 this implementation is largely based on: https://code.google.com/archive/p/pam-face-authentication (GSOC 2009)

 use it like:


 Ptr<face::MACE> mace = face::MACE::create(64);

 vector<Mat> pos_images = ...
 mace->train(pos_images);

 Mat query = ...
 bool same = mace->same(query);



 you can also use two-factor authentication, with an additional passphrase:


 String owners_passphrase = "ilikehotdogs";
 Ptr<face::MACE> mace = face::MACE::create(64);
 mace->salt(owners_passphrase);
 vector<Mat> pos_images = ...
 mace->train(pos_images);

 // now, users have to give a valid passphrase, along with the image:
 Mat query = ...
 cout << "enter passphrase: ";
 string pass;
 getline(cin, pass);
 mace->salt(pass);
 bool same = mace->same(query);


 save/load your model:

 Ptr<face::MACE> mace = face::MACE::create(64);
 mace->train(pos_images);
 mace->save("my_mace.xml");

 // later:
 Ptr<MACE> reloaded = MACE::load("my_mace.xml");
 reloaded->same(some_image);

Member of Face

Class implementing the MSD (Maximal Self-Dissimilarity) keypoint detector, described in CITE: Tombari14.

The algorithm implements a novel interest point detector stemming from the intuition that image patches which are highly dissimilar over a relatively large extent of their surroundings hold the property of being repeatable and distinctive. This concept of “contextual self-dissimilarity” reverses the key paradigm of recent successful techniques such as the Local Self-Similarity descriptor and the Non-Local Means filter, which build upon the presence of similar - rather than dissimilar - patches. Moreover, it extends to contextual information the local self-dissimilarity notion embedded in established detectors of corner-like interest points, thereby achieving enhanced repeatability, distinctiveness and localization accuracy.

Member of Xfeatures2d

Maximally stable extremal region extractor

The class encapsulates all the parameters of the %MSER extraction algorithm (see wiki article).

• there are two different implementation of %MSER: one for grey image, one for color image

• the grey image algorithm is taken from: CITE: nister2008linear ; the paper claims to be faster than union-find method; it actually get 1.5~2m/s on my centrino L7200 1.2GHz laptop.

• the color image algorithm is taken from: CITE: forssen2007maximally ; it should be much slower than grey image method ( 3~4 times ); the chi_table.h file is taken directly from paper’s source code which is distributed under GPL.

• (Python) A complete example showing the use of the %MSER detector can be found at samples/python/mser.py

Member of Features2d

Marr-Hildreth Operator Based Hash, slowest but more discriminative.

See CITE: zauner2010implementation for details.

Member of Img_hash

The class Mat represents an n-dimensional dense numerical single-channel or multi-channel array.

Mat representation of an array of bytes

Mat representation of an array of DMatch objects

Mat representation of an array of doubles

Mat representation of an array of floats

Mat representation of an array of vectors of four floats

Mat representation of an array of vectors of six floats

Mat representation of an array of ints

Mat representation of an array of vectors of four ints

Mat representation of an array of KeyPoint objects

Mat representation of an array of Point2f objects

Mat representation of an array of Point objects

Mat representation of an array of Point3i objects

Mat representation of an array of Point3f objects

Mat representation of an array of Rect2d objects

Mat representation of an array of Rect objects

Mat representation of an array of RotatedRect objects

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

For more information see CITE: DM97 .

Member of Photo

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

Member of Photo

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 .

Member of Photo

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

For more information see CITE: RB99 .

Member of Photo

Result of operation to determine global minimum and maximum of an array

The Ml module

Member classes: ParamGrid, TrainData, StatModel, NormalBayesClassifier, KNearest, SVM, EM, DTrees, RTrees, Boost, ANN_MLP, LogisticRegression, SVMSGD

Member enums: VariableTypes, ErrorTypes, SampleTypes, StatModelFlags, KNearestTypes, SVMTypes, KernelTypes, ParamTypes, EMTypes, DTreeFlags, Types, TrainingMethods, ActivationFunctions, TrainFlags, RegKinds, Methods, SvmsgdType, MarginType

This class is presented high-level API for neural networks.

Model allows to set params for preprocessing input image. Model creates net from file with trained weights and config, sets preprocessing input and runs forward pass.

Member of Dnn

This class is used to track multiple objects using the specified tracker algorithm.

The %MultiTracker is naive implementation of multiple object tracking. It process the tracked objects independently without any optimization accross the tracked objects.

Member of Tracking

This class allows to create and manipulate comprehensive artificial neural networks.

Neural network is presented as directed acyclic graph (DAG), where vertices are Layer instances, and edges specify relationships between layers inputs and outputs.

Each network layer has unique integer id and unique string name inside its network. LayerId can store either layer name or layer id.

This class supports reference counting of its instances, i. e. copies point to the same instance.

Member of Dnn

Bayes classifier for normally distributed data.

Member of Ml

OCRBeamSearchDecoder class provides an interface for OCR using Beam Search algorithm.

@note - (C++) An example on using OCRBeamSearchDecoder recognition combined with scene text detection can be found at the demo sample: https://github.com/opencv/opencv_contrib/blob/master/modules/text/samples/word_recognition.cpp

Member of Text

Callback with the character classifier is made a class.

 This way it hides the feature extractor and the classifier itself, so developers can write
 their own OCR code.

 The default character classifier and feature extractor can be loaded using the utility function
 loadOCRBeamSearchClassifierCNN with all its parameters provided in
 <https://github.com/opencv/opencv_contrib/blob/master/modules/text/samples/OCRBeamSearch_CNN_model_data.xml.gz>.

Member of Text

OCRHMMDecoder class provides an interface for OCR using Hidden Markov Models.

@note - (C++) An example on using OCRHMMDecoder recognition combined with scene text detection can be found at the webcam_demo sample: https://github.com/opencv/opencv_contrib/blob/master/modules/text/samples/webcam_demo.cpp

Member of Text

Callback with the character classifier is made a class.

 This way it hides the feature extractor and the classifier itself, so developers can write
 their own OCR code.

 The default character classifier and feature extractor can be loaded using the utility function
 loadOCRHMMClassifierNM and KNN model provided in
 <https://github.com/opencv/opencv_contrib/blob/master/modules/text/samples/OCRHMM_knn_model_data.xml.gz>.

Member of Text

OCRTesseract class provides an interface with the tesseract-ocr API (v3.02.02) in C++.

Notice that it is compiled only when tesseract-ocr is correctly installed.

@note - (C++) An example of OCRTesseract recognition combined with scene text detection can be found at the end_to_end_recognition demo: https://github.com/opencv/opencv_contrib/blob/master/modules/text/samples/end_to_end_recognition.cpp - (C++) Another example of OCRTesseract recognition combined with scene text detection can be found at the webcam_demo: https://github.com/opencv/opencv_contrib/blob/master/modules/text/samples/webcam_demo.cpp

Member of Text

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

Member of Features2d

The Objdetect module

Member classes: BaseCascadeClassifier, CascadeClassifier, HOGDescriptor, QRCodeDetector

Member enums: HistogramNormType, DescriptorStorageFormat, ObjectStatus

Class implementing PCT (position-color-texture) signature extraction as described in CITE: 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.

A signature is an array of SIGNATURE_DIMENSION-dimensional points. Used dimensions are: weight, x, y position; lab color, contrast, entropy. CITE: KrulisLS16 CITE: BeecksUS10

Member of Xfeatures2d

Class implementing Signature Quadratic Form Distance (SQFD).

Member of Xfeatures2d

pHash

Slower than average_hash, but tolerant of minor modifications

This algorithm can combat more variation than averageHash, for more details please refer to CITE: lookslikeit

Member of Img_hash

The structure represents the logarithmic grid range of statmodel parameters.

It is used for optimizing statmodel accuracy by varying model parameters, the accuracy estimate being computed by cross-validation.

Member of Ml

Abstract base class for phase unwrapping.

Member of Phase_unwrapping

The Phase_unwrapping module

Member classes: HistogramPhaseUnwrapping, HistogramPhaseUnwrappingParams, PhaseUnwrapping

The Photo module

Member classes: Tonemap, TonemapDrago, TonemapReinhard, TonemapMantiuk, AlignExposures, AlignMTB, CalibrateCRF, CalibrateDebevec, CalibrateRobertson, MergeExposures, MergeDebevec, MergeMertens, MergeRobertson

The Plot module

Member classes: Plot2d

plot Plot function for Mat data

Member of Plot

Represents a two dimensional point the coordinate values of which are of type double

Represents a two dimensional point the coordinate values of which are of type float

Represents a two dimensional point the coordinate values of which are of type int

Represents a three dimensional point the coordinate values of which are of type double

Represents a three dimensional point the coordinate values of which are of type float