All Classes Interface Summary Class Summary Exception Summary
| Class |
Description |
| AdaptiveManifoldFilter |
Interface for Adaptive Manifold Filter realizations.
|
| AffineFeature |
Class for implementing the wrapper which makes detectors and extractors to be affine invariant,
described as ASIFT in CITE: YM11 .
|
| AffineFeature2D |
Class implementing affine adaptation for key points.
|
| AgastFeatureDetector |
Wrapping class for feature detection using the AGAST method.
|
| AKAZE |
Class implementing the AKAZE keypoint detector and descriptor extractor, described in CITE: ANB13.
|
| Algorithm |
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.
|
| 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.
|
| ANN_MLP |
Artificial Neural Networks - Multi-Layer Perceptrons.
|
| Aruco |
|
| ArucoDetector |
The main functionality of ArucoDetector class is detection of markers in an image with detectMarkers() method.
|
| AverageHash |
Computes average hash value of the input image
This is a fast image hashing algorithm, but only work on simple case.
|
| BackgroundSubtractor |
Base class for background/foreground segmentation.
|
| BackgroundSubtractorCNT |
Background subtraction based on counting.
|
| BackgroundSubtractorGMG |
Background Subtractor module based on the algorithm given in CITE: Gold2012 .
|
| BackgroundSubtractorGSOC |
Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
|
| BackgroundSubtractorKNN |
K-nearest neighbours - based Background/Foreground Segmentation Algorithm.
|
| BackgroundSubtractorLSBP |
Background Subtraction using Local SVD Binary Pattern.
|
| BackgroundSubtractorLSBPDesc |
This is for calculation of the LSBP descriptors.
|
| BackgroundSubtractorMOG |
Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
|
| BackgroundSubtractorMOG2 |
Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
|
| Barcode |
|
| BarcodeDetector |
|
| BaseCascadeClassifier |
|
| BaseOCR |
|
| BasicFaceRecognizer |
|
| BEBLID |
Class implementing BEBLID (Boosted Efficient Binary Local Image Descriptor),
described in CITE: Suarez2020BEBLID .
|
| BFMatcher |
Brute-force descriptor matcher.
|
| Bgsegm |
|
| BIF |
Implementation of bio-inspired features (BIF) from the paper:
Guo, Guodong, et al.
|
| Bioinspired |
|
| BlockMeanHash |
Image hash based on block mean.
|
| Board |
Board of ArUco markers
A board is a set of markers in the 3D space with a common coordinate system.
|
| Boost |
Boosted tree classifier derived from DTrees
SEE: REF: ml_intro_boost
|
| BoostDesc |
Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in
CITE: Trzcinski13a and CITE: Trzcinski13b.
|
| 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.
|
| BriefDescriptorExtractor |
Class for computing BRIEF descriptors described in CITE: calon2010 .
|
| BRISK |
Class implementing the BRISK keypoint detector and descriptor extractor, described in CITE: LCS11 .
|
| Calib3d |
|
| 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.
|
| CascadeClassifier |
Cascade classifier class for object detection.
|
| CharucoBoard |
ChArUco board is a planar chessboard where the markers are placed inside the white squares of a chessboard.
|
| CharucoDetector |
|
| CharucoParameters |
|
| CLAHE |
Base class for Contrast Limited Adaptive Histogram Equalization.
|
| ClassificationModel |
This class represents high-level API for classification models.
|
| ColorMomentHash |
Image hash based on color moments.
|
| ContourFitting |
Class for ContourFitting algorithms.
|
| Converters |
|
| Core |
|
| Core.MinMaxLocResult |
|
| CvException |
|
| CvType |
|
| DAISY |
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.
|
| DenseOpticalFlow |
Base class for dense optical flow algorithms
|
| DescriptorMatcher |
Abstract base class for matching keypoint descriptors.
|
| DetectionModel |
This class represents high-level API for object detection networks.
|
| DetectorParameters |
struct DetectorParameters is used by ArucoDetector
|
| Dictionary |
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.
|
| DictValue |
This struct stores the scalar value (or array) of one of the following type: double, cv::String or int64.
|
| DISOpticalFlow |
DIS optical flow algorithm.
|
| DisparityFilter |
Main interface for all disparity map filters.
|
| DisparityWLSFilter |
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.
|
| DMatch |
Structure for matching: query descriptor index, train descriptor index, train
image index and distance between descriptors.
|
| Dnn |
|
| DTFilter |
Interface for realizations of Domain Transform filter.
|
| DTrees |
The class represents a single decision tree or a collection of decision trees.
|
| EdgeAwareInterpolator |
Sparse match interpolation algorithm based on modified locally-weighted affine
estimator from CITE: Revaud2015 and Fast Global Smoother as post-processing filter.
|
| EdgeBoxes |
Class implementing EdgeBoxes algorithm from CITE: ZitnickECCV14edgeBoxes :
|
| EdgeDrawing |
Class implementing the ED (EdgeDrawing) CITE: topal2012edge, EDLines CITE: akinlar2011edlines, EDPF CITE: akinlar2012edpf and EDCircles CITE: akinlar2013edcircles algorithms
|
| EdgeDrawing_Params |
|
| EigenFaceRecognizer |
|
| EM |
The class implements the Expectation Maximization algorithm.
|
| ERFilter |
Base class for 1st and 2nd stages of Neumann and Matas scene text detection algorithm CITE: Neumann12.
|
| ERFilter_Callback |
Callback with the classifier is made a class.
|
| EstimateParameters |
Pose estimation parameters
pattern Defines center this system and axes direction (default PatternPositionType::ARUCO_CCW_CENTER).
|
| Face |
|
| FaceDetectorYN |
DNN-based face detector
model download link: https://github.com/opencv/opencv_zoo/tree/master/models/face_detection_yunet
|
| Facemark |
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.
|
| FacemarkAAM |
|
| FacemarkKazemi |
|
| FacemarkLBF |
|
| FacemarkTrain |
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.
|
| FaceRecognizer |
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.
|
| FaceRecognizerSF |
DNN-based face recognizer
model download link: https://github.com/opencv/opencv_zoo/tree/master/models/face_recognition_sface
|
| FarnebackOpticalFlow |
Class computing a dense optical flow using the Gunnar Farneback's algorithm.
|
| FastBilateralSolverFilter |
Interface for implementations of Fast Bilateral Solver.
|
| FastFeatureDetector |
Wrapping class for feature detection using the FAST method.
|
| FastGlobalSmootherFilter |
Interface for implementations of Fast Global Smoother filter.
|
| FastLineDetector |
Class implementing the FLD (Fast Line Detector) algorithm described
in CITE: Lee14 .
|
| Feature2D |
Abstract base class for 2D image feature detectors and descriptor extractors
|
| Features2d |
|
| FisherFaceRecognizer |
|
| FlannBasedMatcher |
Flann-based descriptor matcher.
|
| FREAK |
Class implementing the FREAK (*Fast Retina Keypoint*) keypoint descriptor, described in CITE: AOV12 .
|
| GeneralizedHough |
finds arbitrary template in the grayscale image using Generalized Hough Transform
|
| GeneralizedHoughBallard |
finds arbitrary template in the grayscale image using Generalized Hough Transform
Detects position only without translation and rotation CITE: Ballard1981 .
|
| GeneralizedHoughGuil |
finds arbitrary template in the grayscale image using Generalized Hough Transform
Detects position, translation and rotation CITE: Guil1999 .
|
| GFTTDetector |
Wrapping class for feature detection using the goodFeaturesToTrack function.
|
| GraphSegmentation |
Graph Based Segmentation Algorithm.
|
| GrayCodePattern |
Class implementing the Gray-code pattern, based on CITE: UNDERWORLD.
|
| GrayworldWB |
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.
|
| GridBoard |
Planar board with grid arrangement of markers
More common type of board.
|
| GuidedFilter |
Interface for realizations of Guided Filter.
|
| HarrisLaplaceFeatureDetector |
Class implementing the Harris-Laplace feature detector as described in CITE: Mikolajczyk2004.
|
| HighGui |
This class was designed for use in Java applications
to recreate the OpenCV HighGui functionalities.
|
| HistogramPhaseUnwrapping |
Class implementing two-dimensional phase unwrapping based on CITE: histogramUnwrapping
This algorithm belongs to the quality-guided phase unwrapping methods.
|
| HistogramPhaseUnwrapping_Params |
Parameters of phaseUnwrapping constructor.
|
| HOGDescriptor |
Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector.
|
| ImageWindow |
This class was designed to create and manipulate
the Windows to be used by the HighGui class.
|
| Img_hash |
|
| Imgcodecs |
|
| ImgHashBase |
The base class for image hash algorithms
|
| Imgproc |
|
| IntelligentScissorsMB |
Intelligent Scissors image segmentation
This class is used to find the path (contour) between two points
which can be used for image segmentation.
|
| KalmanFilter |
Kalman filter class.
|
| KAZE |
Class implementing the KAZE keypoint detector and descriptor extractor, described in CITE: ABD12 .
|
| KeyPoint |
|
| KeypointsModel |
This class represents high-level API for keypoints models
KeypointsModel allows to set params for preprocessing input image.
|
| KNearest |
The class implements K-Nearest Neighbors model
SEE: REF: ml_intro_knn
|
| LATCH |
latch Class for computing the LATCH descriptor.
|
| Layer |
This interface class allows to build new Layers - are building blocks of networks.
|
| LBPHFaceRecognizer |
|
| LearningBasedWB |
More sophisticated learning-based automatic white balance algorithm.
|
| legacy_MultiTracker |
This class is used to track multiple objects using the specified tracker algorithm.
|
| legacy_Tracker |
Base abstract class for the long-term tracker:
|
| legacy_TrackerBoosting |
the Boosting tracker
This is a real-time object tracking based on a novel on-line version of the AdaBoost algorithm.
|
| legacy_TrackerCSRT |
the CSRT tracker
The implementation is based on CITE: Lukezic_IJCV2018 Discriminative Correlation Filter with Channel and Spatial Reliability
|
| legacy_TrackerKCF |
the KCF (Kernelized Correlation Filter) tracker
KCF is a novel tracking framework that utilizes properties of circulant matrix to enhance the processing speed.
|
| legacy_TrackerMedianFlow |
the Median Flow tracker
Implementation of a paper CITE: MedianFlow .
|
| legacy_TrackerMIL |
The MIL algorithm trains a classifier in an online manner to separate the object from the
background.
|
| legacy_TrackerMOSSE |
the MOSSE (Minimum Output Sum of Squared %Error) tracker
The implementation is based on CITE: MOSSE Visual Object Tracking using Adaptive Correlation Filters
Note: this tracker works with grayscale images, if passed bgr ones, they will get converted internally.
|
| legacy_TrackerTLD |
the TLD (Tracking, learning and detection) tracker
TLD is a novel tracking framework that explicitly decomposes the long-term tracking task into
tracking, learning and detection.
|
| LineSegmentDetector |
Line segment detector class
following the algorithm described at CITE: Rafael12 .
|
| LogisticRegression |
Implements Logistic Regression classifier.
|
| LUCID |
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.
|
| MACE |
Minimum Average Correlation Energy Filter
useful for authentication with (cancellable) biometrical features.
|
| MarrHildrethHash |
Marr-Hildreth Operator Based Hash, slowest but more discriminative.
|
| Mat |
|
| Mat.Atable<T> |
|
| Mat.Tuple2<T> |
|
| Mat.Tuple3<T> |
|
| Mat.Tuple4<T> |
|
| MatOfByte |
|
| MatOfDMatch |
|
| MatOfDouble |
|
| MatOfFloat |
|
| MatOfFloat4 |
|
| MatOfFloat6 |
|
| MatOfInt |
|
| MatOfInt4 |
|
| MatOfKeyPoint |
|
| MatOfPoint |
|
| MatOfPoint2f |
|
| MatOfPoint3 |
|
| MatOfPoint3f |
|
| MatOfRect |
|
| MatOfRect2d |
|
| MatOfRotatedRect |
|
| 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 well-exposedness 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.
|
| Ml |
|
| Model |
This class is presented high-level API for neural networks.
|
| Moments |
|
| MSDDetector |
Class implementing the MSD (*Maximal Self-Dissimilarity*) keypoint detector, described in CITE: Tombari14.
|
| MSER |
Maximally stable extremal region extractor
The class encapsulates all the parameters of the %MSER extraction algorithm (see [wiki
article](http://en.wikipedia.org/wiki/Maximally_stable_extremal_regions)).
|
| Net |
This class allows to create and manipulate comprehensive artificial neural networks.
|
| NormalBayesClassifier |
Bayes classifier for normally distributed data.
|
| Objdetect |
|
| OCRBeamSearchDecoder |
OCRBeamSearchDecoder class provides an interface for OCR using Beam Search algorithm.
|
| OCRBeamSearchDecoder_ClassifierCallback |
Callback with the character classifier is made a class.
|
| OCRHMMDecoder |
OCRHMMDecoder class provides an interface for OCR using Hidden Markov Models.
|
| OCRHMMDecoder_ClassifierCallback |
Callback with the character classifier is made a class.
|
| OCRTesseract |
OCRTesseract class provides an interface with the tesseract-ocr API (v3.02.02) in C++.
|
| OpenCVInterface |
Dummy interface to allow some integration testing within OSGi implementation.
|
| OpenCVNativeLoader |
This class is intended to provide a convenient way to load OpenCV's native
library from the Java bundle.
|
| ORB |
Class implementing the ORB (*oriented BRIEF*) keypoint detector and descriptor extractor
described in CITE: RRKB11 .
|
| ParamGrid |
The structure represents the logarithmic grid range of statmodel parameters.
|
| PCTSignatures |
Class implementing PCT (position-color-texture) signature extraction
as described in CITE: KrulisLS16.
|
| PCTSignaturesSQFD |
Class implementing Signature Quadratic Form Distance (SQFD).
|
| Phase_unwrapping |
|
| PhaseUnwrapping |
Abstract base class for phase unwrapping.
|
| PHash |
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
|
| Photo |
|
| Plot |
|
| Plot2d |
plot Plot function for Mat data
|
| Point |
|
| Point3 |
|
| PredictCollector |
Abstract base class for all strategies of prediction result handling
|
| QRCodeDetector |
|
| QRCodeEncoder |
Groups the object candidate rectangles.
|
| QRCodeEncoder_Params |
QR code encoder parameters.
|
| RadialVarianceHash |
Image hash based on Radon transform.
|
| Range |
|
| Rect |
|
| Rect2d |
|
| RefineParameters |
struct RefineParameters is used by ArucoDetector
|
| Retina |
class which allows the Gipsa/Listic Labs model to be used with OpenCV.
|
| RetinaFastToneMapping |
a wrapper class which allows the tone mapping algorithm of Meylan&al(2007) to be used with OpenCV.
|
| RFFeatureGetter |
Jun 17, 2014
|
| RICInterpolator |
Sparse match interpolation algorithm based on modified piecewise locally-weighted affine
estimator called Robust Interpolation method of Correspondences or RIC from CITE: Hu2017 and Variational
and Fast Global Smoother as post-processing filter.
|
| RidgeDetectionFilter |
Applies Ridge Detection Filter to an input image.
|
| RotatedRect |
|
| RTrees |
The class implements the random forest predictor.
|
| Scalar |
|
| ScanSegment |
Class implementing the F-DBSCAN (Accelerated superpixel image segmentation with a parallelized DBSCAN algorithm) superpixels
algorithm by Loke SC, et al.
|
| SegmentationModel |
This class represents high-level API for segmentation models
SegmentationModel allows to set params for preprocessing input image.
|
| SelectiveSearchSegmentation |
Selective search segmentation algorithm
The class implements the algorithm described in CITE: uijlings2013selective.
|
| SelectiveSearchSegmentationStrategy |
Strategie for the selective search segmentation algorithm
The class implements a generic stragery for the algorithm described in CITE: uijlings2013selective.
|
| SelectiveSearchSegmentationStrategyColor |
Color-based strategy for the selective search segmentation algorithm
The class is implemented from the algorithm described in CITE: uijlings2013selective.
|
| SelectiveSearchSegmentationStrategyFill |
Fill-based strategy for the selective search segmentation algorithm
The class is implemented from the algorithm described in CITE: uijlings2013selective.
|
| SelectiveSearchSegmentationStrategyMultiple |
Regroup multiple strategies for the selective search segmentation algorithm
|
| SelectiveSearchSegmentationStrategySize |
Size-based strategy for the selective search segmentation algorithm
The class is implemented from the algorithm described in CITE: uijlings2013selective.
|
| SelectiveSearchSegmentationStrategyTexture |
Texture-based strategy for the selective search segmentation algorithm
The class is implemented from the algorithm described in CITE: uijlings2013selective.
|
| SIFT |
Class for extracting keypoints and computing descriptors using the Scale Invariant Feature Transform
(SIFT) algorithm by D.
|
| SimpleBlobDetector |
Class for extracting blobs from an image.
|
| SimpleBlobDetector_Params |
|
| SimpleWB |
A simple white balance algorithm that works by independently stretching
each of the input image channels to the specified range.
|
| SinusoidalPattern |
Class implementing Fourier transform profilometry (FTP) , phase-shifting profilometry (PSP)
and Fourier-assisted phase-shifting profilometry (FAPS) based on CITE: faps.
|
| SinusoidalPattern_Params |
Parameters of SinusoidalPattern constructor
width Projector's width.
|
| Size |
|
| SparseMatchInterpolator |
Main interface for all filters, that take sparse matches as an
input and produce a dense per-pixel matching (optical flow) as an output.
|
| SparseOpticalFlow |
Base interface for sparse optical flow algorithms.
|
| SparsePyrLKOpticalFlow |
Class used for calculating a sparse optical flow.
|
| StandardCollector |
Default predict collector
Trace minimal distance with treshhold checking (that is default behavior for most predict logic)
|
| StarDetector |
The class implements the keypoint detector introduced by CITE: Agrawal08, synonym of StarDetector.
|
| 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.
|
| Structured_light |
|
| StructuredEdgeDetection |
Class implementing edge detection algorithm from CITE: Dollar2013 :
|
| StructuredLightPattern |
Abstract base class for generating and decoding structured light patterns.
|
| Subdiv2D |
|
| SuperpixelLSC |
Class implementing the LSC (Linear Spectral Clustering) superpixels
algorithm described in CITE: LiCVPR2015LSC.
|
| SuperpixelSEEDS |
Class implementing the SEEDS (Superpixels Extracted via Energy-Driven Sampling) superpixels
algorithm described in CITE: VBRV14 .
|
| SuperpixelSLIC |
Class implementing the SLIC (Simple Linear Iterative Clustering) superpixels
algorithm described in CITE: Achanta2012.
|
| SURF |
Class for extracting Speeded Up Robust Features from an image CITE: Bay06 .
|
| SURF_CUDA |
Class used for extracting Speeded Up Robust Features (SURF) from an image.
|
| SVM |
Support Vector Machines.
|
| SVMSGD |
*************************************************************************************\
Stochastic Gradient Descent SVM Classifier *
\***************************************************************************************
|
| SyntheticSequenceGenerator |
Synthetic frame sequence generator for testing background subtraction algorithms.
|
| TBMR |
Class implementing the Tree Based Morse Regions (TBMR) as described in
CITE: Najman2014 extended with scaled extraction ability.
|
| TEBLID |
Class implementing TEBLID (Triplet-based Efficient Binary Local Image Descriptor),
described in CITE: Suarez2021TEBLID.
|
| TermCriteria |
|
| Text |
|
| TextDetectionModel |
Base class for text detection networks
|
| TextDetectionModel_DB |
This class represents high-level API for text detection DL networks compatible with DB model.
|
| TextDetectionModel_EAST |
This class represents high-level API for text detection DL networks compatible with EAST model.
|
| TextDetector |
An abstract class providing interface for text detection algorithms
|
| TextDetectorCNN |
TextDetectorCNN class provides the functionallity of text bounding box detection.
|
| TextRecognitionModel |
This class represents high-level API for text recognition networks.
|
| TickMeter |
a Class to measure passing time.
|
| Tonemap |
Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range.
|
| TonemapDrago |
Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in
logarithmic domain.
|
| 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.
|
| Tracker |
Base abstract class for the long-term tracker
|
| TrackerCSRT |
the CSRT tracker
The implementation is based on CITE: Lukezic_IJCV2018 Discriminative Correlation Filter with Channel and Spatial Reliability
|
| TrackerCSRT_Params |
|
| TrackerDaSiamRPN |
|
| TrackerDaSiamRPN_Params |
|
| TrackerGOTURN |
the GOTURN (Generic Object Tracking Using Regression Networks) tracker
GOTURN (CITE: GOTURN) is kind of trackers based on Convolutional Neural Networks (CNN).
|
| TrackerGOTURN_Params |
|
| TrackerKCF |
the KCF (Kernelized Correlation Filter) tracker
KCF is a novel tracking framework that utilizes properties of circulant matrix to enhance the processing speed.
|
| TrackerKCF_Params |
|
| TrackerMIL |
The MIL algorithm trains a classifier in an online manner to separate the object from the
background.
|
| TrackerMIL_Params |
|
| TrackerNano |
the Nano tracker is a super lightweight dnn-based general object tracking.
|
| TrackerNano_Params |
|
| Tracking |
|
| TrainData |
Class encapsulating training data.
|
| TransientAreasSegmentationModule |
class which provides a transient/moving areas segmentation module
perform a locally adapted segmentation by using the retina magno input data Based on Alexandre
BENOIT thesis: "Le système visuel humain au secours de la vision par ordinateur"
3 spatio temporal filters are used:
a first one which filters the noise and local variations of the input motion energy
a second (more powerfull low pass spatial filter) which gives the neighborhood motion energy the
segmentation consists in the comparison of these both outputs, if the local motion energy is higher
to the neighborhood otion energy, then the area is considered as moving and is segmented
a stronger third low pass filter helps decision by providing a smooth information about the
"motion context" in a wider area
|
| UsacParams |
|
| VariationalRefinement |
Variational optical flow refinement
This class implements variational refinement of the input flow field, i.e.
|
| VGG |
Class implementing VGG (Oxford Visual Geometry Group) descriptor trained end to end
using "Descriptor Learning Using Convex Optimisation" (DLCO) aparatus described in CITE: Simonyan14.
|
| Video |
|
| VideoCapture |
Class for video capturing from video files, image sequences or cameras.
|
| Videoio |
|
| VideoWriter |
Video writer class.
|
| Wechat_qrcode |
|
| WeChatQRCode |
WeChat QRCode includes two CNN-based models:
A object detection model and a super resolution model.
|
| WhiteBalancer |
The base class for auto white balance algorithms.
|
| Xfeatures2d |
|
| Ximgproc |
|
| Xphoto |
|