Module opencv::hub_prelude [−][src]
Traits
Class implementing the AKAZE keypoint detector and descriptor extractor, described in ANB13.
Artificial Neural Networks - Multi-Layer Perceptrons.
Interface for Adaptive Manifold Filter realizations.
Class for implementing the wrapper which makes detectors and extractors to be affine invariant, described as ASIFT in YM11 .
Class implementing affine adaptation for key points.
Wrapper class for the OpenCV Affine Transformation algorithm. :
Affine warper factory class.
Wrapping class for feature detection using the AGAST method. :
This is a base class for all more or less complex algorithms in OpenCV
The base class for algorithms that align images of the same scene with different exposures
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.
Wrapper for OpenGL Client-Side Vertex arrays.
Returns result of asynchronous operations
Provides result of asynchronous operations
Computes average hash value of the input image
Class implementing BEBLID (Boosted Efficient Binary Local Image Descriptor), described in Suarez2020BEBLID .
Brute-force descriptor matcher.
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.
Class to compute an image descriptor using the bag of visual words.
kmeans -based class to train visual vocabulary using the bag of visual words approach. :
Abstract base class for training the bag of visual words vocabulary from a set of descriptors.
Class implementing the BRISK keypoint detector and descriptor extractor, described in LCS11 .
Derivatives of this class encapsulates functions of certain backends.
Derivatives of this class wraps cv::Mat for different backends and targets.
Base class for background/foreground segmentation. :
Background subtraction based on counting.
Background Subtractor module based on the algorithm given in Gold2012 .
Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
K-nearest neighbours - based Background/Foreground Segmentation Algorithm.
Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at LGuo2016
This is for calculation of the LSBP descriptors.
Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
base class BaseSFM declares a common API that would be used in a typical scene reconstruction scenario
furnishes all functionalities for querying a dataset provided by user or internal to class (that user must, anyway, populate) on the model of @ref features2d_match
Class implements both functionalities for detection of lines and computation of their binary descriptor.
List of BinaryDescriptor parameters:
Partial List of Implemented Layers
Image hash based on block mean.
Board of markers
Boosted tree classifier derived from DTrees
Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in Trzcinski13a and Trzcinski13b.
Class for computing BRIEF descriptors described in calon2010 .
BufferPool for use with CUDA streams
Smart pointer for OpenGL buffer object with reference counting.
Base class for Contrast Limited Adaptive Histogram Equalization.
Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
Class computing the optical flow for two images using Brox et al Optical Flow algorithm (Brox2004).
Base class for Contrast Limited Adaptive Histogram Equalization. :
Base class for Canny Edge Detector. :
Base class for Cornerness Criteria computation. :
Base class for Corners Detector. :
Base interface for dense optical flow algorithms.
Class used for calculating a dense optical flow.
Abstract base class for matching keypoint descriptors.
Class refining a disparity map using joint bilateral filtering. :
Class computing a dense optical flow using the Gunnar Farneback’s algorithm.
Wrapping class for feature detection using the FAST method.
Abstract base class for CUDA asynchronous 2D image feature detectors and descriptor extractors.
Base class for circles detector algorithm. :
Base class for lines detector algorithm. :
Base class for line segments detector algorithm. :
Base Interface for optical flow algorithms using NVIDIA Optical Flow SDK.
Class for computing the optical flow vectors between two images using NVIDIA Optical Flow hardware and Optical Flow SDK 1.0.
Class for computing the optical flow vectors between two images using NVIDIA Optical Flow hardware and Optical Flow SDK 2.0.
Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor
Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method.
Base interface for sparse optical flow algorithms.
Class used for calculating a sparse optical flow.
Class computing stereo correspondence (disparity map) using the block matching algorithm. :
Class computing stereo correspondence using the belief propagation algorithm. :
Class computing stereo correspondence using the constant space belief propagation algorithm. :
The class implements the modified H. Hirschmuller algorithm HH08. Limitation and difference are as follows:
Base class for Template Matching. :
The base class for camera response calibration algorithms.
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.
Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system. This algorithm uses all image pixels.
Optional information about a location in Code.
This class wraps intrinsic parameters of a camera.
Cascade classifier class used for object detection. Supports HAAR and LBP cascades. :
@example samples/cpp/facedetect.cpp This program demonstrates usage of the Cascade classifier class \image html Cascade_Classifier_Tutorial_Result_Haar.jpg “Sample screenshot” width=321 height=254
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.
An Chi based cost extraction. :
This class represents high-level API for classification models.
Core class of ccm model
Image hash based on color moments.
This class represents color in BGR order.
KinectFusion implementation
Designed for command line parsing
This class is used to perform the non-linear non-constrained minimization of a function with known gradient,
Constant layer produces the same data blob at an every forward pass.
Class for ContourFitting algorithms. ContourFitting match two contours
inline formula
andinline formula
minimizing distanceblock formula
whereinline formula
andinline formula
are Fourier descriptors ofinline formula
andinline formula
and s is a scaling factor andinline formula
is angle rotation andinline formula
is starting point factor adjustementBase class for convolution (or cross-correlation) operator. :
Cylindrical warper factory class.
Class implementing DAISY descriptor, described in Tola10
Base class for DFT operator as a cv::Algorithm. :
DIS optical flow algorithm.
This is a C++ abstract class, it provides external user API to work with DPM.
Interface for realizations of Domain Transform filter.
The class represents a single decision tree or a collection of decision trees.
The class represents a decision tree node.
The class represents split in a decision tree.
Base class for dense optical flow algorithms
Fast dense optical flow computation based on robust local optical flow (RLOF) algorithms and sparse-to-dense interpolation scheme.
Object that can clean a noisy depth image
Abstract base class for matching keypoint descriptors.
Affine transformation based estimator.
Features matcher similar to cv::detail::BestOf2NearestMatcher 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.
Affine warper that uses rotations and translations
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
Base class for all blenders.
Exposure compensator which tries to remove exposure related artifacts by adjusting image block on each channel.
Exposure compensator which tries to remove exposure related artifacts by adjusting image blocks.
Exposure compensator which tries to remove exposure related artifacts by adjusting image block intensities, see UES01 for details.
Bundle adjuster that expects affine transformation with 4 DOF represented in homogeneous coordinates in R for each camera param. Implements camera parameters refinement algorithm which minimizes sum of the reprojection error squares
Bundle adjuster that expects affine transformation represented in homogeneous coordinates in R for each camera param. Implements camera parameters refinement algorithm which minimizes sum of the reprojection error squares
Base class for all camera parameters refinement methods.
Implementation of the camera parameters refinement algorithm which minimizes sum of the distances between the rays passing through the camera center and a feature. :
Implementation of the camera parameters refinement algorithm which minimizes sum of the reprojection error squares
Describes camera parameters.
Exposure compensator which tries to remove exposure related artifacts by adjusting image intensities on each channel independently.
Warper that maps an image onto the x*x + z*z = 1 cylinder.
Rotation estimator base class.
Base class for all exposure compensators.
Simple blender which mixes images at its borders.
Feature matchers base class.
Exposure compensator which tries to remove exposure related artifacts by adjusting image intensities, see BL07 and WJ10 for details.
Base class for all minimum graph-cut-based seam estimators.
Minimum graph cut-based seam estimator. See details in V03 .
Homography based rotation estimator.
Structure containing image keypoints and descriptors.
Structure containing information about matches between two images.
Blender which uses multi-band blending algorithm (see BA83).
Stub bundle adjuster that does nothing.
Stub exposure compensator which does nothing.
Stub seam estimator which does nothing.
Base class for all pairwise seam estimators.
Warper that maps an image onto the z = 1 plane.
Base class for warping logic implementation.
Rotation-only model image warper interface.
Base class for a seam estimator.
Warper that maps an image onto the unit sphere located at the origin.
Voronoi diagram-based seam estimator.
This class represents high-level API for object detection networks.
Detection output layer.
struct for detection region of interest (ROI)
Parameters for the detectMarker process:
Class providing functionality for querying the specified GPU properties.
This class implements name-value dictionary, values are instances of DictValue.
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.
Dictionary/Set of markers. It contains the inner codification
Main interface for all disparity map filters.
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.
A class to upscale images via convolutional neural networks. The following four models are implemented:
This class is used to perform the non-linear non-constrained minimization of a function,
“Dual TV L1” Optical Flow Algorithm.
The class implements the Expectation Maximization algorithm.
An EMD based cost extraction. :
An EMD-L1 based cost extraction. :
Base class for 1st and 2nd stages of Neumann and Matas scene text detection algorithm Neumann12. :
Callback with the classifier is made a class.
The ERStat structure represents a class-specific Extremal Region (ER).
Sparse match interpolation algorithm based on modified locally-weighted affine estimator from Revaud2015 and Fast Global Smoother as post-processing filter.
Class implementing EdgeBoxes algorithm from ZitnickECCV14edgeBoxes :
Class implementing the ED (EdgeDrawing) topal2012edge, EDLines akinlar2011edlines, EDPF akinlar2012edpf and EDCircles akinlar2013edcircles algorithms
Elliptic region around an interest point.
Element wise operation on inputs
Callbacks for CUDA video encoder.
Different parameters for CUDA video encoder.
! Class passed to an error.
Class implementing the FREAK (Fast Retina Keypoint) keypoint descriptor, described in AOV12 .
Abstract base class for all face recognition models
Abstract base class for all facemark models
\brief Optional parameter for fitting process.
\brief Data container for the facemark::getData function
\brief The model of AAM Algorithm
Abstract base class for trainable facemark models
Class computing a dense optical flow using the Gunnar Farneback’s algorithm.
Interface for implementations of Fast Bilateral Solver.
Wrapping class for feature detection using the FAST method. :
Interface for implementations of Fast Global Smoother filter.
A faster version of ICPOdometry which is used in KinectFusion implementation Partial list of differences:
@include samples/fld_lines.cpp
Describes the Fast Marching Method implementation.
used to iterate through sequences and mappings.
File Storage Node class.
XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or reading data to/from a file.
Common interface for all CUDA filters :
Flann-based descriptor matcher.
@todo document
@todo document
Wrapping class for feature detection using the goodFeaturesToTrack function. :
implements “Global optimal searching for textureless 3D object tracking” wang2015global
Class encapsulating training samples.
Class for individual tree.
finds arbitrary template in the grayscale image using Generalized Hough Transform
finds arbitrary template in the grayscale image using Generalized Hough Transform
finds arbitrary template in the grayscale image using Generalized Hough Transform
Base storage class for GPU memory with reference counting.
Graph Based Segmentation Algorithm. The class implements the algorithm described in PFF2004 .
Class implementing the Gray-code pattern, based on UNDERWORLD.
Parameters of StructuredLightPattern constructor.
Gray-world white balance algorithm
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 also: drawPlanarBoard)
Interface for realizations of Guided Filter.
Hierarchical Data Format version 5 interface.
The class implements Histogram of Oriented Gradients (Dalal2005) object detector.
Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector.
Class implementing the Harris-Laplace feature detector as described in Mikolajczyk2004.
Abstract base class for histogram cost algorithms.
Class implementing two-dimensional phase unwrapping based on histogramUnwrapping This algorithm belongs to the quality-guided phase unwrapping methods. First, it computes a reliability map from second differences between a pixel and its eight neighbours. Reliability values lie between 0 and 16pipi. 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.
Class with reference counting wrapping special memory type allocation functions from CUDA.
Odometry based on the paper “KinectFusion: Real-Time Dense Surface Mapping and Tracking”, Richard A. Newcombe, Andrew Fitzgibbon, at al, SIGGRAPH, 2011.
This class implements a very efficient and robust variant of the iterative closest point (ICP) algorithm. The task is to register a 3D model (or point cloud) against a set of noisy target data. The variants are put together by myself after certain tests. The task is to be able to match partial, noisy point clouds in cluttered scenes, quickly. You will find that my emphasis is on the performance, while retaining the accuracy. This implementation is based on Tolga Birdal’s MATLAB implementation in here: http://www.mathworks.com/matlabcentral/fileexchange/47152-icp-registration-using-efficient-variants-and-multi-resolution-scheme The main contributions come from:
Base class for global 2D motion estimation methods which take frames as input.
The base class for image hash algorithms
Intelligent Scissors image segmentation
Bilinear resize layer from https://github.com/cdmh/deeplab-public-ver2
Class implementing the KAZE keypoint detector and descriptor extractor, described in ABD12 .
The class implements K-Nearest Neighbors model
Kalman filter class.
A class filters a vector of keypoints.
This class represents a keyboard event.
Describes a global 2D motion estimation method which uses keypoints detection and optical flow for matching.
This class represents high-level API for keypoints models
KinectFusion implementation
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
Linear Discriminant Analysis @todo document this class
Levenberg-Marquardt solver. Starting with the specified vector of parameters it optimizes the target vector criteria “err” (finds local minima of each target vector component absolute value).
LSTM recurrent layer
Class implementing the locally uniform comparison image descriptor, described in LUCID
Large Scale Dense Depth Fusion implementation
%Layer factory allows to create instances of registered layers.
This class provides all data needed to initialize layer.
This interface class allows to build new Layers - are building blocks of networks.
More sophisticated learning-based automatic white balance algorithm.
Line iterator
Line segment detector class
\brief Modality that computes quantized gradient orientations from a color image.
\brief Modality that computes quantized surface normals from a dense depth map.
\brief Object detector using the LINE template matching algorithm with any set of modalities.
\brief Represents a successful template match.
\brief Interface for modalities that plug into the LINE template matching representation.
\brief Represents a modality operating over an image pyramid.
Implements Logistic Regression classifier.
Base class for transform using lookup table.
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)
CChecker
A class to find the positions of the ColorCharts in the image.
\brief checker draw
Parameters for the detectMarker process:
Class implementing the MSD (Maximal Self-Dissimilarity) keypoint detector, described in Tombari14.
Maximally stable extremal region extractor
Marr-Hildreth Operator Based Hash, slowest but more discriminative.
/////////////////////////////// MatConstIterator //////////////////////////////////
Matrix expression representation @anchor MatrixExpressions This is a list of implemented matrix operations that can be combined in arbitrary complex expressions (here A, B stand for matrices ( Mat ), s for a scalar ( Scalar ), alpha for a real-valued scalar ( double )):
////////////////////////////// Matrix Expressions /////////////////////////////////
n-dimensional dense array class \anchor CVMat_Details
@cond IGNORED
The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response.
The base class algorithms that can merge exposure sequence to a single image.
Pixels are weighted using contrast, saturation and well-exposedness measures, than images are combined using laplacian pyramids.
The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response.
This class wraps mesh attributes, and it can load a mesh from a ply file. :
Basic interface for all solvers
Represents function being optimized
This class is presented high-level API for neural networks.
Base class for all global motion estimation methods.
Describes a global 2D motion estimation method which minimizes L1 error.
Describes a robust RANSAC-based global 2D motion estimation method which minimizes L2 error.
********************************* Motion Saliency Base Class ***********************************
!
This class represents a mouse event.
Class for multiple camera calibration that supports pinhole camera and omnidirection camera. For omnidirectional camera model, please refer to omnidir.hpp in ccalib module. It first calibrate each camera individually, then a bundle adjustment like optimization is applied to refine extrinsic parameters. So far, it only support “random” pattern for calibration, see randomPattern.hpp in ccalib module for details. Images that are used should be named by “cameraIdx-timestamp.*”, several images with the same timestamp means that they are the same pattern that are photographed. cameraIdx should start from 0.
This class allows to create and manipulate comprehensive artificial neural networks.
A norm based cost extraction. :
Bayes classifier for normally distributed data.
inline formula
- normalization layer.OCRBeamSearchDecoder class provides an interface for OCR using Beam Search algorithm.
Callback with the character classifier is made a class.
OCRHMMDecoder class provides an interface for OCR using Hidden Markov Models.
Callback with the character classifier is made a class.
OCRHolisticWordRecognizer class provides the functionallity of segmented wordspotting. Given a predefined vocabulary , a DictNet is employed to select the most probable word given an input image.
OCRTesseract class provides an interface with the tesseract-ocr API (v3.02.02) in C++.
implements “Optimal local searching for fast and robust textureless 3D object tracking in highly cluttered backgrounds” seo2013optimal
Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor
********************************* Objectness Base Class ***********************************
the Binarized normed gradients algorithm from BING
Base class for computation of odometry.
Object that contains a frame data that is possibly needed for the Odometry. It’s used for the efficiency (to pass precomputed/cached data of the frame that participates in the Odometry processing several times).
PCAFlow algorithm.
@brief This class can be used for imposing a learned prior on the resulting optical flow. Solution will be regularized according to this prior. You need to generate appropriate prior file with “learn_prior.py” script beforehand.
Principal Component Analysis
Class implementing PCT (position-color-texture) signature extraction as described in KrulisLS16. The algorithm is divided to a feature sampler and a clusterizer. Feature sampler produces samples at given set of coordinates. Clusterizer then produces clusters of these samples using k-means algorithm. Resulting set of clusters is the signature of the input image.
Class implementing Signature Quadratic Form Distance (SQFD).
pHash
Class, allowing the load and matching 3D models. Typical Use:
Adds extra values for specific axes.
Base class for parallel data processors
The structure represents the logarithmic grid range of statmodel parameters.
Abstract base class for phase unwrapping.
Plane warper factory class.
@deprecated
Class, allowing the storage of a pose. The data structure stores both the quaternions and the matrix forms. It supports IO functionality together with various helper methods to work with poses
When multiple poses (see Pose3D) are grouped together (contribute to the same transformation) pose clusters occur. This class is a general container for such groups of poses. It is possible to store, load and perform IO on these poses.
Abstract base class for all strategies of prediction result handling
QtFont available only for Qt. See cv::fontQt
BRISQUE (Blind/Referenceless Image Spatial Quality Evaluator) is a No Reference Image Quality Assessment (NR-IQA) algorithm.
********************************* Quality Base Class ***********************************
Full reference GMSD algorithm http://www4.comp.polyu.edu.hk/~cslzhang/IQA/GMSD/GMSD.htm
Full reference mean square error algorithm https://en.wikipedia.org/wiki/Mean_squared_error
Full reference peak signal to noise ratio (PSNR) algorithm https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
Full reference structural similarity algorithm https://en.wikipedia.org/wiki/Structural_similarity
Class containing the methods needed for Quasi Dense Stereo computation.
! Helper class for training part of [P. Dollar and C. L. Zitnick. Structured Forests for Fast Edge Detection, 2013].
Sparse match interpolation algorithm based on modified piecewise locally-weighted affine estimator called Robust Interpolation method of Correspondences or RIC from Hu2017 and Variational and Fast Global Smoother as post-processing filter. The RICInterpolator is a extension of the EdgeAwareInterpolator. Main concept of this extension is an piece-wise affine model based on over-segmentation via SLIC superpixel estimation. The method contains an efficient propagation mechanism to estimate among the pieces-wise models.
This is used store and set up the parameters of the robust local optical flow (RLOF) algoritm.
Random Number Generator
Mersenne Twister random number generator
Classical recurrent layer
The class implements the random forest predictor.
Image hash based on Radon transform.
Class for finding features points and corresponding 3D in world coordinate of a “random” pattern, which can be to be used in calibration. It is useful when pattern is partly occluded or only a part of pattern can be observed in multiple cameras calibration. The pattern can be generated by RandomPatternGenerator class described in this file.
Template class specifying a continuous subsequence (slice) of a sequence.
Describes RANSAC method parameters.
wrapper around @ref rapid function for uniform access
Interface for video demultiplexing. :
Resize input 4-dimensional blob by nearest neighbor or bilinear strategy.
class which allows the Gipsa/Listic Labs model to be used with OpenCV.
a wrapper class which allows the tone mapping algorithm of Meylan&al(2007) to be used with OpenCV.
retina model parameters structure
Object that contains a frame data.
Odometry that merges RgbdOdometry and ICPOdometry by minimize sum of their energy functions.
Object that can compute the normals in an image. It is an object as it can cache data for speed efficiency The implemented methods are either:
Odometry based on the paper “Real-Time Visual Odometry from Dense RGB-D Images”, F. Steinbucker, J. Strum, D. Cremers, ICCV, 2011.
Object that can compute planes in an image
Applies Ridge Detection Filter to an input image. Implements Ridge detection similar to the one in Mathematica using the eigen values from the Hessian Matrix of the input image using Sobel Derivatives. Additional refinement can be done using Skeletonization and Binarization. Adapted from segleafvein and M_RF
The class represents rotated (i.e. not up-right) rectangles on a plane.
SFMLibmvEuclideanReconstruction class provides an interface with the Libmv Structure From Motion pipeline.
Class for extracting keypoints and computing descriptors using the Scale Invariant Feature Transform (SIFT) algorithm by D. Lowe Lowe04 .
Class for extracting Speeded Up Robust Features from an image Bay06 .
Class used for extracting Speeded Up Robust Features (SURF) from an image. :
Singular Value Decomposition
Support Vector Machines.
! Stochastic Gradient Descent SVM classifier
********************************* Saliency Base Class ***********************************
This class represents high-level API for segmentation models
Selective search segmentation algorithm The class implements the algorithm described in uijlings2013selective.
Strategie for the selective search segmentation algorithm The class implements a generic stragery for the algorithm described in uijlings2013selective.
Color-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in uijlings2013selective.
Fill-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in uijlings2013selective.
Regroup multiple strategies for the selective search segmentation algorithm
Size-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in uijlings2013selective.
Texture-based strategy for the selective search segmentation algorithm The class is implemented from the algorithm described in uijlings2013selective.
@example modules/shape/samples/shape_example.cpp An example using shape distance algorithm
Abstract base class for shape transformation algorithms.
Permute channels of 4-dimensional input blob.
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)
Class for extracting blobs from an image. :
A simple white balance algorithm that works by independently stretching each of the input image channels to the specified range. For increased robustness it ignores the top and bottom
inline formula
of pixel values.Class implementing Fourier transform profilometry (FTP) , phase-shifting profilometry (PSP) and Fourier-assisted phase-shifting profilometry (FAPS) based on faps.
Parameters of SinusoidalPattern constructor
Slice layer has several modes:
Read-Only Sparse Matrix Iterator.
Read-write Sparse Matrix Iterator
The class SparseMat represents multi-dimensional sparse numerical arrays.
the sparse matrix header
sparse matrix node - element of a hash table
Main interface for all filters, that take sparse matches as an input and produce a dense per-pixel matching (optical flow) as an output.
Base interface for sparse optical flow algorithms.
Class used for calculating a sparse optical flow.
Class used for calculation sparse optical flow and feature tracking with robust local optical flow (RLOF) algorithms.
Spherical warper factory class
Default predict collector
The class implements the keypoint detector introduced by Agrawal08, synonym of StarDetector. :
Base class for statistical models in OpenCV ML.
********************************* Static Saliency Base Class ***********************************
the Fine Grained Saliency approach from FGS
the Spectral Residual approach from SR
Class for computing stereo correspondence using the block matching algorithm, introduced and contributed to OpenCV by K. Konolige.
The base class for stereo correspondence algorithms.
The class implements the modified H. Hirschmuller algorithm HH08 that differs from the original one as follows:
High level image stitcher.
This class encapsulates a queue of asynchronous calls.
Class implementing edge detection algorithm from Dollar2013 :
Abstract base class for generating and decoding structured light patterns.
Class implementing the LSC (Linear Spectral Clustering) superpixels algorithm described in LiCVPR2015LSC.
Class implementing the SEEDS (Superpixels Extracted via Energy-Driven Sampling) superpixels algorithm described in VBRV14 .
Class implementing the SLIC (Simple Linear Iterative Clustering) superpixels algorithm described in Achanta2012.
Base class for Super Resolution algorithms.
Synthetic frame sequence generator for testing background subtraction algorithms.
Class implementing the Tree Based Morse Regions (TBMR) as described in Najman2014 extended with scaled extraction ability.
TLS container base implementation
Class providing a set of static methods to check what NVIDIA* card architecture the CUDA module was built for.
This class represents high-level API for text detection DL networks compatible with DB model.
This class represents high-level API for text detection DL networks compatible with EAST model.
An abstract class providing interface for text detection algorithms
TextDetectorCNN class provides the functionallity of text bounding box detection.
This class is representing to find bounding boxes of text words given an input image.
This class uses OpenCV dnn module to load pre-trained model described in LiaoSBWL17.
The original repository with the modified SSD Caffe version: https://github.com/MhLiao/TextBoxes.
Model can be downloaded from DropBox.
Modified .prototxt file with the model description can be found in opencv_contrib/modules/text/samples/textbox.prototxt.
This class represents high-level API for text recognition networks.
Smart pointer for OpenGL 2D texture memory with reference counting.
Definition of the transformation
a Class to measure passing time.
Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range.
Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in logarithmic domain.
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.
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.
This is a global tonemapping operator that models human visual system.
Abstract base class for stateful silhouette trackers
Base abstract class for the long-term tracker
the CSRT tracker
the GOTURN (Generic Object Tracking Using Regression Networks) tracker
the KCF (Kernelized Correlation Filter) tracker
The MIL algorithm trains a classifier in an online manner to separate the object from the background.
Class encapsulating training data.
class which provides a transient/moving areas segmentation module
@todo document
Class implementing VGG (Oxford Visual Geometry Group) descriptor trained end to end using “Descriptor Learning Using Convex Optimisation” (DLCO) aparatus described in Simonyan14.
Variational optical flow refinement
Class for video capturing from video files, image sequences or cameras.
Video reader interface.
Video writer interface.
Video writer class.
The Viz3d class represents a 3D visualizer window. This class is implicitly shared.
This 3D Widget defines an arrow.
WaldBoost detector
This 3D Widget represents camera position in a scene by its axes or viewing frustum. :
This 3D Widget defines a circle.
This 3D Widget defines a collection of clouds. :
This 3D Widget represents normals of a point cloud. :
This 3D Widget defines a point cloud. :
This 3D Widget defines a cone. :
This 3D Widget represents a coordinate system. :
This 3D Widget defines a cube.
This 3D Widget defines a cylinder. :
This 3D Widget defines a grid. :
This 3D Widget represents an image in 3D space. :
This 2D Widget represents an image overlay. :
This 3D Widget defines a finite line.
Constructs a WMesh.
This 3D Widget defines a finite plane.
This 3D Widget defines a poly line. :
This 3D Widget defines a sphere. :
This 3D Widget represents 3D text. The text always faces the camera.
This 2D Widget represents text overlay.
This 3D Widget represents a trajectory. :
This 3D Widget represents a trajectory using spheres and lines
This 3D Widget represents a trajectory. :
This class allows to merge several widgets to single one.
Image warper factories base class.
The base class for auto white balance algorithms.
Base class of all 2D widgets.
Base class of all 3D widgets.
Base class of all widgets. Widget is implicitly shared.
A 3D viewport and the associated scene
This is the proxy class for passing read-only input arrays into OpenCV functions.
This type is very similar to InputArray except that it is used for input/output and output function parameters.