Module opencv::prelude

source ·

Structs

n-dimensional dense array class \anchor CVMat_Details

Traits

Class implementing the AKAZE keypoint detector and descriptor extractor, described in ANB13.
Artificial Neural Networks - Multi-Layer Perceptrons.
Constant methods for crate::ml::ANN_MLP
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. :
Wrapping class for feature detection using the AGAST method. :
Mutable methods for core::Algorithm
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.
Mutable methods for core::Arrays
Constant methods for core::Arrays
Class implementing BEBLID (Boosted Efficient Binary Local Image Descriptor), described in Suarez2020BEBLID .
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.
Constant methods for crate::face::BIF
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 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
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
Constant methods for crate::sfm::BaseSFM
Boosted tree classifier derived from DTrees
Constant methods for crate::ml::Boost
Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in Trzcinski13a and Trzcinski13b.
Trait for structures that are created on the C++ side, usually only the raw void pointer is stored to point to the allocated data on the heap.
Class for computing BRIEF descriptors described in calon2010 .
Mutable methods for core::Buffer
Constant methods for core::Buffer
Base class for Contrast Limited Adaptive Histogram Equalization.
Constant methods for crate::imgproc::CLAHE
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.
Mutable methods for crate::viz::Camera
Cascade classifier class used for object detection. Supports HAAR and LBP cascades. :
An Chi based cost extraction. :
Mutable methods for crate::viz::Color
KinectFusion implementation
This class is used to perform the non-linear non-constrained minimization of a function with known gradient,
Mutable methods for core::Context
Constant methods for core::Context
Base class for convolution (or cross-correlation) operator. :
Class implementing DAISY descriptor, described in Tola10
Base class for DFT operator as a cv::Algorithm. :
Constant methods for crate::cudaarithm::DFT
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.
Constant methods for crate::ml::DTrees
Mutable methods for crate::gapi::Data
Constant methods for crate::gapi::Data
This sealed trait is implemented for types that are valid to use as Mat elements
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.
Abstract base class for matching keypoint descriptors.
Exposure compensator which tries to remove exposure related artifacts by adjusting image blocks.
Base class for all camera parameters refinement methods.
Rotation estimator base class.
Base class for all exposure compensators.
Feature matchers base class.
Base class for all pairwise seam estimators.
Rotation-only model image warper interface.
Base class for a seam estimator.
Mutable methods for core::Device
Constant methods for core::Device
Mutable methods for crate::dnn::Dict
Constant methods for crate::dnn::Dict
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.
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.
Constant methods for crate::ml::EM
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.
Mutable methods for crate::text::ERStat
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
Interface for encoder callbacks.
Mutable methods for core::Event
Constant methods for core::Event
Mutable methods for core::Exception
Class implementing the FREAK (Fast Retina Keypoint) keypoint descriptor, described in AOV12 .
DNN-based face detector
Abstract base class for all face recognition models
DNN-based face recognizer
Abstract base class for all facemark models
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.
@include samples/fld_lines.cpp
Mutable methods for core::FileNode
Common interface for all CUDA filters :
@todo document
Constant methods for core::Formatted
@todo document
Constant methods for core::Formatter
Mutable methods for crate::gapi::GArg
Constant methods for crate::gapi::GArg
Mutable methods for crate::gapi::GCall
Wrapping class for feature detection using the goodFeaturesToTrack function. :
Mutable methods for crate::gapi::GFrame
@private
Mutable methods for crate::gapi::GMatP
Mutable methods for crate::gapi::GMat
Constant methods for crate::gapi::GMat
implements “Global optimal searching for textureless 3D object tracking” wang2015global
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
Mutable methods for core::GpuData
Constant methods for core::GpuData
Mutable methods for core::GpuMatND
Mutable methods for core::GpuMat
Constant methods for core::GpuMat
Graph Based Segmentation Algorithm. The class implements the algorithm described in PFF2004 .
Class implementing the Gray-code pattern, based on UNDERWORLD.
Gray-world white balance algorithm
Interface for realizations of Guided Filter.
Hierarchical Data Format version 5 interface.
Constant methods for crate::hdf::HDF5
The class implements Histogram of Oriented Gradients (Dalal2005) object detector.
Mutable methods for core::Hamming
Constant methods for core::Hamming
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.
Mutable methods for core::HostMem
Constant methods for core::HostMem
Constant methods for crate::videostab::ILog
Mutable methods for core::Image2D
Constant methods for core::Image2D
Base class for global 2D motion estimation methods which take frames as input.
Mutable methods for crate::gapi::Image
Mutable methods for crate::flann::Index
Class implementing the KAZE keypoint detector and descriptor extractor, described in ABD12 .
The class implements K-Nearest Neighbors model
Mutable methods for core::KernelArg
Mutable methods for core::Kernel
Constant methods for core::Kernel
Mutable methods for core::KeyPoint
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
Mutable methods for core::LDA
Constant methods for core::LDA
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
Mutable methods for crate::dnn::Layer
More sophisticated learning-based automatic white balance algorithm.
Line segment detector class
\brief Interface for modalities that plug into the LINE template matching representation.
\brief Represents a modality operating over an image pyramid.
Mutable methods for core::LogTag
Constant methods for core::LogTag
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)
Constant methods for crate::face::MACE
CChecker
A class to find the positions of the ColorCharts in the image.
\brief checker draw
Class implementing the MSD (Maximal Self-Dissimilarity) keypoint detector, described in Tombari14.
Maximally stable extremal region extractor
Mutable methods for core::MatExpr
Constant methods for core::MatExpr
////////////////////////////// Matrix Expressions /////////////////////////////////
Constant methods for core::MatOp
Mutable methods for core::MatSize
Constant methods for core::MatSize
Mutable methods for core::MatStep
Constant methods for core::MatStep
Mutable methods for core::Mat
Constant methods for core::Mat
Mutable methods for core::Matx_TOp
An interface class for MediaFrame data adapters.
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.
Mutable methods for crate::viz::Mesh
Constant methods for crate::viz::Mesh
Basic interface for all solvers
Represents function being optimized
Mutable methods for crate::dnn::Model
Base class for all global motion estimation methods.
********************************* Motion Saliency Base Class ***********************************
Mutable methods for crate::dnn::Net
Constant methods for crate::dnn::Net
Mutable methods for core::NodeData
A norm based cost extraction. :
Bayes classifier for normally distributed data.
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
Constant methods for crate::features2d::ORB
********************************* Objectness Base Class ***********************************
Base class for computation of odometry.
Mutable methods for core::PCA
Constant methods for core::PCA
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).
Base class for parallel data processors
Mutable methods for crate::rgbd::Params
Abstract base class for phase unwrapping.
Mutable methods for core::Platform
Constant methods for crate::plot::Plot2d
Mutable methods for crate::gapi::Poly
Constant methods for crate::gapi::Poly
Abstract base class for all strategies of prediction result handling
Mutable methods for core::Program
Constant methods for core::Program
********************************* Quality Base Class ***********************************
Class containing the methods needed for Quasi Dense Stereo computation.
Mutable methods for core::Queue
Constant methods for core::Queue
! 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.
Mutable methods for crate::gapi::RMat
Constant methods for crate::gapi::RMat
Mutable methods for core::RNG
Constant methods for core::RNG
Classical recurrent layer
The class implements the random forest predictor.
Constant methods for crate::ml::RTrees
Mutable methods for core::Range
Constant methods for core::Range
wrapper around rapid function for uniform access
Constant methods for crate::rapid::Rapid
Interface for video demultiplexing. :
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.
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
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 .
Mutable methods for core::SVD
Constant methods for core::SVD
Support Vector Machines.
Constant methods for crate::ml::SVM
! Stochastic Gradient Descent SVM classifier
Constant methods for crate::ml::SVMSGD
********************************* Saliency Base Class ***********************************
Mutable methods for crate::gapi::Scalar
Class implementing the F-DBSCAN (Accelerated superpixel image segmentation with a parallelized DBSCAN algorithm) superpixels algorithm by Loke SC, et al. loke2021accelerated for original paper.
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.
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.
Mutable methods for core::SparseMat
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.
The class implements the keypoint detector introduced by Agrawal08, synonym of StarDetector. :
Base class for statistical models in OpenCV ML.
********************************* Static Saliency Base Class ***********************************
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:
Mutable methods for core::Stream
Constant methods for core::Stream
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.
Class implementing the Tree Based Morse Regions (TBMR) as described in Najman2014 extended with scaled extraction ability.
TLS container base implementation
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.
Mutable methods for crate::gapi::Text
Constant methods for crate::gapi::Text
Mutable methods for core::Texture2D
Definition of the transformation
Mutable methods for core::TickMeter
Mutable methods for core::Timer
Constant methods for core::Timer
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.
the Nano tracker is a super lightweight dnn-based general object tracking.
Class encapsulating training data.
class which provides a transient/moving areas segmentation module
Mutable methods for core::UMatData
Mutable methods for core::UMat
Constant methods for core::UMat
Class implementing VGG (Oxford Visual Geometry Group) descriptor trained end to end using “Descriptor Learning Using Convex Optimisation” (DLCO) aparatus described in Simonyan14.
Constant methods for crate::xfeatures2d::VGG
Variational optical flow refinement
Video reader interface.
Video writer interface.
Mutable methods for crate::viz::Viz3d
Mutable methods for crate::viz::WArrow
WaldBoost detector
Mutable methods for crate::viz::WCloud
Mutable methods for crate::viz::WCone
Mutable methods for crate::viz::WCube
Mutable methods for crate::viz::WGrid
Mutable methods for crate::viz::WLine
Mutable methods for crate::viz::WMesh
Mutable methods for crate::viz::WPlane
Mutable methods for crate::viz::WText
Image warper factories base class.
The base class for auto white balance algorithms.
Mutable methods for crate::viz::Widget
A 3D viewport and the associated scene
Mutable methods for crate::dnn::_Range
Mutable methods for crate::gapi::any
Constant methods for crate::gapi::any