OpenCV
3.4.19
Open Source Computer Vision
|
Classes | |
class | cv::BaseClassifier |
class | cv::ClassifierThreshold |
class | cv::ClfMilBoost |
class | cv::ClfOnlineStump |
class | cv::CvFeatureEvaluator |
class | cv::CvFeatureParams |
class | cv::CvHaarEvaluator |
class | cv::CvHaarFeatureParams |
class | cv::CvHOGEvaluator |
struct | cv::CvHOGFeatureParams |
class | cv::CvLBPEvaluator |
struct | cv::CvLBPFeatureParams |
class | cv::CvParams |
class | cv::Detector |
class | cv::EstimatedGaussDistribution |
class | cv::MultiTracker |
This class is used to track multiple objects using the specified tracker algorithm. More... | |
class | cv::MultiTracker_Alt |
Base abstract class for the long-term Multi Object Trackers: More... | |
class | cv::MultiTrackerTLD |
Multi Object Tracker for TLD. More... | |
class | cv::StrongClassifierDirectSelection |
class | cv::Tracker |
Base abstract class for the long-term tracker: More... | |
class | cv::TrackerBoosting |
the Boosting tracker More... | |
class | cv::TrackerCSRT |
the CSRT tracker More... | |
class | cv::TrackerFeature |
Abstract base class for TrackerFeature that represents the feature. More... | |
class | cv::TrackerFeatureFeature2d |
TrackerFeature based on Feature2D. More... | |
class | cv::TrackerFeatureHAAR |
TrackerFeature based on HAAR features, used by TrackerMIL and many others algorithms. More... | |
class | cv::TrackerFeatureHOG |
TrackerFeature based on HOG. More... | |
class | cv::TrackerFeatureLBP |
TrackerFeature based on LBP. More... | |
class | cv::TrackerFeatureSet |
Class that manages the extraction and selection of features. More... | |
class | cv::TrackerGOTURN |
the GOTURN (Generic Object Tracking Using Regression Networks) tracker More... | |
class | cv::TrackerKCF |
the KCF (Kernelized Correlation Filter) tracker More... | |
class | cv::TrackerMedianFlow |
the Median Flow tracker More... | |
class | cv::TrackerMIL |
The MIL algorithm trains a classifier in an online manner to separate the object from the background. More... | |
class | cv::TrackerModel |
Abstract class that represents the model of the target. It must be instantiated by specialized tracker. More... | |
class | cv::TrackerMOSSE |
the MOSSE (Minimum Output Sum of Squared Error) tracker More... | |
class | cv::TrackerSampler |
Class that manages the sampler in order to select regions for the update the model of the tracker [AAM] Sampling e Labeling. See table I and section III B. More... | |
class | cv::TrackerSamplerAlgorithm |
Abstract base class for TrackerSamplerAlgorithm that represents the algorithm for the specific sampler. More... | |
class | cv::TrackerSamplerCS |
TrackerSampler based on CS (current state), used by algorithm TrackerBoosting. More... | |
class | cv::TrackerSamplerCSC |
TrackerSampler based on CSC (current state centered), used by MIL algorithm TrackerMIL. More... | |
class | cv::TrackerSamplerPF |
This sampler is based on particle filtering. More... | |
class | cv::TrackerStateEstimator |
Abstract base class for TrackerStateEstimator that estimates the most likely target state. More... | |
class | cv::TrackerStateEstimatorAdaBoosting |
TrackerStateEstimatorAdaBoosting based on ADA-Boosting. More... | |
class | cv::TrackerStateEstimatorMILBoosting |
TrackerStateEstimator based on Boosting. More... | |
class | cv::TrackerStateEstimatorSVM |
TrackerStateEstimator based on SVM. More... | |
class | cv::TrackerTargetState |
Abstract base class for TrackerTargetState that represents a possible state of the target. More... | |
class | cv::TrackerTLD |
the TLD (Tracking, learning and detection) tracker More... | |
class | cv::WeakClassifierHaarFeature |
Macros | |
#define | CC_FEATURE_PARAMS "featureParams" |
#define | CC_FEATURE_SIZE "featSize" |
#define | CC_FEATURES FEATURES |
#define | CC_ISINTEGRAL "isIntegral" |
#define | CC_MAX_CAT_COUNT "maxCatCount" |
#define | CC_NUM_FEATURES "numFeat" |
#define | CC_RECT "rect" |
#define | CC_RECTS "rects" |
#define | CC_TILTED "tilted" |
#define | CV_HAAR_FEATURE_MAX 3 |
#define | CV_SUM_OFFSETS(p0, p1, p2, p3, rect, step) |
#define | CV_TILTED_OFFSETS(p0, p1, p2, p3, rect, step) |
#define | FEATURES "features" |
#define | HFP_NAME "haarFeatureParams" |
#define | HOGF_NAME "HOGFeatureParams" |
#define | LBPF_NAME "lbpFeatureParams" |
#define | N_BINS 9 |
#define | N_CELLS 4 |
Typedefs | |
typedef std::vector< std::pair< Ptr< TrackerTargetState >, float > > | cv::ConfidenceMap |
Represents the model of the target at frame \(k\) (all states and scores) More... | |
typedef std::vector< Ptr< TrackerTargetState > > | cv::Trajectory |
Represents the estimate states for all frames. More... | |
Functions | |
template<class Feature > | |
void | cv::_writeFeatures (const std::vector< Feature > features, FileStorage &fs, const Mat &featureMap) |
float | cv::CvHOGEvaluator::Feature::calc (const std::vector< Mat > &_hists, const Mat &_normSum, size_t y, int featComponent) const |
uchar | cv::CvLBPEvaluator::Feature::calc (const Mat &_sum, size_t y) const |
float | cv::calcNormFactor (const Mat &sum, const Mat &sqSum) |
virtual float | cv::CvHOGEvaluator::operator() (int varIdx, int sampleIdx) CV_OVERRIDE |
Long-term optical tracking is an important issue for many computer vision applications in real world scenario. The development in this area is very fragmented and this API is an unique interface useful for plug several algorithms and compare them. This work is partially based on [188] and [131] .
These algorithms start from a bounding box of the target and with their internal representation they avoid the drift during the tracking. These long-term trackers are able to evaluate online the quality of the location of the target in the new frame, without ground truth.
There are three main components: the TrackerSampler, the TrackerFeatureSet and the TrackerModel. The first component is the object that computes the patches over the frame based on the last target location. The TrackerFeatureSet is the class that manages the Features, is possible plug many kind of these (HAAR, HOG, LBP, Feature2D, etc). The last component is the internal representation of the target, it is the appearance model. It stores all state candidates and compute the trajectory (the most likely target states). The class TrackerTargetState represents a possible state of the target. The TrackerSampler and the TrackerFeatureSet are the visual representation of the target, instead the TrackerModel is the statistical model.
A recent benchmark between these algorithms can be found in [240]
If you want to create a new tracker, here's what you have to do. First, decide on the name of the class for the tracker (to meet the existing style, we suggest something with prefix "tracker", e.g. trackerMIL, trackerBoosting) – we shall refer to this choice as to "classname" in subsequent.
Every tracker has three component TrackerSampler, TrackerFeatureSet and TrackerModel. The first two are instantiated from Tracker base class, instead the last component is abstract, so you must implement your TrackerModel.
TrackerSampler is already instantiated, but you should define the sampling algorithm and add the classes (or single class) to TrackerSampler. You can choose one of the ready implementation as TrackerSamplerCSC or you can implement your sampling method, in this case the class must inherit TrackerSamplerAlgorithm. Fill the samplingImpl method that writes the result in "sample" output argument.
Example of creating specialized TrackerSamplerAlgorithm TrackerSamplerCSC : :
Example of adding TrackerSamplerAlgorithm to TrackerSampler : :
TrackerFeatureSet is already instantiated (as first) , but you should define what kinds of features you'll use in your tracker. You can use multiple feature types, so you can add a ready implementation as TrackerFeatureHAAR in your TrackerFeatureSet or develop your own implementation. In this case, in the computeImpl method put the code that extract the features and in the selection method optionally put the code for the refinement and selection of the features.
Example of creating specialized TrackerFeature TrackerFeatureHAAR : :
Example of adding TrackerFeature to TrackerFeatureSet : :
TrackerModel is abstract, so in your implementation you must develop your TrackerModel that inherit from TrackerModel. Fill the method for the estimation of the state "modelEstimationImpl", that estimates the most likely target location, see [188] table I (ME) for further information. Fill "modelUpdateImpl" in order to update the model, see [188] table I (MU). In this class you can use the :cConfidenceMap and :cTrajectory to storing the model. The first represents the model on the all possible candidate states and the second represents the list of all estimated states.
Example of creating specialized TrackerModel TrackerMILModel : :
And add it in your Tracker : :
In the last step you should define the TrackerStateEstimator based on your implementation or you can use one of ready class as TrackerStateEstimatorMILBoosting. It represent the statistical part of the model that estimates the most likely target state.
Example of creating specialized TrackerStateEstimator TrackerStateEstimatorMILBoosting : :
And add it in your TrackerModel : :
During this step, you should define your TrackerTargetState based on your implementation. TrackerTargetState base class has only the bounding box (upper-left position, width and height), you can enrich it adding scale factor, target rotation, etc.
Example of creating specialized TrackerTargetState TrackerMILTargetState : :
#define CC_FEATURE_PARAMS "featureParams" |
#include <opencv2/tracking/feature.hpp>
#define CC_FEATURE_SIZE "featSize" |
#include <opencv2/tracking/feature.hpp>
#define CC_FEATURES FEATURES |
#include <opencv2/tracking/feature.hpp>
#define CC_ISINTEGRAL "isIntegral" |
#include <opencv2/tracking/feature.hpp>
#define CC_MAX_CAT_COUNT "maxCatCount" |
#include <opencv2/tracking/feature.hpp>
#define CC_NUM_FEATURES "numFeat" |
#include <opencv2/tracking/feature.hpp>
#define CC_RECT "rect" |
#include <opencv2/tracking/feature.hpp>
#define CC_RECTS "rects" |
#include <opencv2/tracking/feature.hpp>
#define CC_TILTED "tilted" |
#include <opencv2/tracking/feature.hpp>
#define CV_HAAR_FEATURE_MAX 3 |
#include <opencv2/tracking/feature.hpp>
#define CV_SUM_OFFSETS | ( | p0, | |
p1, | |||
p2, | |||
p3, | |||
rect, | |||
step | |||
) |
#include <opencv2/tracking/feature.hpp>
#define CV_TILTED_OFFSETS | ( | p0, | |
p1, | |||
p2, | |||
p3, | |||
rect, | |||
step | |||
) |
#include <opencv2/tracking/feature.hpp>
#define FEATURES "features" |
#include <opencv2/tracking/feature.hpp>
#define HFP_NAME "haarFeatureParams" |
#include <opencv2/tracking/feature.hpp>
#define HOGF_NAME "HOGFeatureParams" |
#include <opencv2/tracking/feature.hpp>
#define LBPF_NAME "lbpFeatureParams" |
#include <opencv2/tracking/feature.hpp>
#define N_BINS 9 |
#include <opencv2/tracking/feature.hpp>
#define N_CELLS 4 |
#include <opencv2/tracking/feature.hpp>
typedef std::vector<std::pair<Ptr<TrackerTargetState>, float> > cv::ConfidenceMap |
#include <opencv2/tracking/tracker.hpp>
Represents the model of the target at frame \(k\) (all states and scores)
See [188] The set of the pair \(\langle \hat{x}^{i}_{k}, C^{i}_{k} \rangle\)
typedef std::vector<Ptr<TrackerTargetState> > cv::Trajectory |
#include <opencv2/tracking/tracker.hpp>
Represents the estimate states for all frames.
[188] \(x_{k}\) is the trajectory of the target up to time \(k\)
void cv::_writeFeatures | ( | const std::vector< Feature > | features, |
FileStorage & | fs, | ||
const Mat & | featureMap | ||
) |
#include <opencv2/tracking/feature.hpp>
|
inline |
#include <opencv2/tracking/feature.hpp>
#include <opencv2/tracking/feature.hpp>
#include <opencv2/tracking/feature.hpp>
|
inlinevirtual |
#include <opencv2/tracking/feature.hpp>
Implements cv::CvFeatureEvaluator.