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::CvLBPEvaluator::Feature

class	cv::CvHOGEvaluator::Feature

class	cv::CvHaarEvaluator::FeatureHaar

struct	cv::ROISelector::handlerT

class	cv::MultiTracker
	This class is used to track multiple objects using the specified tracker algorithm. The MultiTracker is naive implementation of multiple object tracking. It process the tracked objects independently without any optimization accross the tracked objects. More...

class	cv::MultiTracker_Alt
	Base abstract class for the long-term Multi Object Trackers: More...

class	cv::MultiTrackerTLD
	Multi Object Tracker for TLD. TLD is a novel tracking framework that explicitly decomposes the long-term tracking task into tracking, learning and detection. More...

struct	cv::TrackerKCF::Params

struct	cv::TrackerTLD::Params

struct	cv::TrackerMedianFlow::Params

struct	cv::TrackerBoosting::Params

struct	cv::TrackerMIL::Params

struct	cv::TrackerFeatureHAAR::Params

struct	cv::TrackerSamplerPF::Params
	This structure contains all the parameters that can be varied during the course of sampling algorithm. Below is the structure exposed, together with its members briefly explained with reference to the above discussion on algorithm's working. More...

struct	cv::TrackerSamplerCS::Params

struct	cv::TrackerSamplerCSC::Params

struct	cv::ClfMilBoost::Params

class	cv::ROISelector

class	cv::StrongClassifierDirectSelection

class	cv::Tracker
	Base abstract class for the long-term tracker: More...

class	cv::TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState
	Implementation of the target state for TrackerAdaBoostingTargetState. More...

class	cv::TrackerBoosting
	This is a real-time object tracking based on a novel on-line version of the AdaBoost algorithm. 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::TrackerKCF
	KCF is a novel tracking framework that utilizes properties of circulant matrix to enhance the processing speed. This tracking method is an implementation of [65] which is extended to KFC with color-names features ([29]). The original paper of KCF is available at http://home.isr.uc.pt/~henriques/circulant/index.html as well as the matlab implementation. For more information about KCF with color-names features, please refer to http://www.cvl.isy.liu.se/research/objrec/visualtracking/colvistrack/index.html. More...

class	cv::TrackerMedianFlow
	Median Flow tracker implementation. More...

class	cv::TrackerMIL
	The MIL algorithm trains a classifier in an online manner to separate the object from the background. More...

class	cv::TrackerStateEstimatorMILBoosting::TrackerMILTargetState

class	cv::TrackerModel
	Abstract class that represents the model of the target. It must be instantiated by specialized 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
	TLD is a novel tracking framework that explicitly decomposes the long-term tracking task into tracking, learning and detection. 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

#define	sign(s) ((s > 0 ) ? 1 : ((s<0) ? -1 : 0))

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

Enumerations
enum	{ cv::CvFeatureParams::HAAR = 0, cv::CvFeatureParams::LBP = 1, cv::CvFeatureParams::HOG = 2 }

enum	{ cv::TrackerSamplerCSC::MODE_INIT_POS = 1, cv::TrackerSamplerCSC::MODE_INIT_NEG = 2, cv::TrackerSamplerCSC::MODE_TRACK_POS = 3, cv::TrackerSamplerCSC::MODE_TRACK_NEG = 4, cv::TrackerSamplerCSC::MODE_DETECT = 5 }

enum	{ cv::TrackerSamplerCS::MODE_POSITIVE = 1, cv::TrackerSamplerCS::MODE_NEGATIVE = 2, cv::TrackerSamplerCS::MODE_CLASSIFY = 3 }

enum	cv::TrackerKCF::MODE { cv::TrackerKCF::GRAY = (1u << 0), cv::TrackerKCF::CN = (1u << 1), cv::TrackerKCF::CUSTOM = (1u << 2) }
	Feature type to be used in the tracking grayscale, colornames, compressed color-names The modes available now: 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)

Rect2d	cv::selectROI (Mat img, bool fromCenter=true)

Rect2d	cv::selectROI (const cv::String &windowName, Mat img, bool showCrossair=true, bool fromCenter=true)

void	cv::selectROI (const cv::String &windowName, Mat img, std::vector< Rect2d > &boundingBox, bool fromCenter=true)

Detailed Description

Long-term optical tracking API

Long-term optical tracking is one of most 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 [124] and [84] .

This 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 appearence 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 [153]

UML design: see Tracking diagrams

To see how API works, try tracker demo: https://github.com/lenlen/opencv/blob/tracking_api/samples/cpp/tracker.cpp

Note: This Tracking API has been designed with PlantUML. If you modify this API please change UML in modules/tracking/doc/tracking_diagrams.markdown. The following reference was used in the API

Creating Own Tracker

If you want 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. Also, you should decide upon the name of the tracker, is it will be known to user (the current style suggests using all capitals, say MIL or BOOSTING) –we'll call it a "name".

Declare your tracker in include/opencv2/tracking/tracker.hpp. Your tracker should inherit from Tracker (please, see the example below). You should declare the specialized Param structure, where you probably will want to put the data, needed to initialize your tracker. Also don't forget to put the BOILERPLATE_CODE(name,classname) macro inside the class declaration. That macro will generate static createTracker() function, which we'll talk about later. You should get something similar to :
class CV_EXPORTS_W TrackerMIL : public Tracker

{

public:

struct CV_EXPORTS Params

{

Params();

//parameters for sampler

float samplerInitInRadius; // radius for gathering positive instances during init

int samplerInitMaxNegNum; // # negative samples to use during init

float samplerSearchWinSize; // size of search window

float samplerTrackInRadius; // radius for gathering positive instances during tracking

int samplerTrackMaxPosNum; // # positive samples to use during tracking

int samplerTrackMaxNegNum; // # negative samples to use during tracking

int featureSetNumFeatures; // #features

void read( const FileNode& fn );

void write( FileStorage& fs ) const;

};

of course, you can also add any additional methods of your choice. It should be pointed out, however, that it is not expected to have a constructor declared, as creation should be done via the corresponding createTracker() method.
In src/tracker.cpp file add BOILERPLATE_CODE(name,classname) line to the body of Tracker::create() method you will find there, like :
Ptr<Tracker> Tracker::create( const String& trackerType )

{

BOILERPLATE_CODE("BOOSTING",TrackerBoosting);

BOILERPLATE_CODE("MIL",TrackerMIL);

return Ptr<Tracker>();

}
Finally, you should implement the function with signature :
Ptr<classname> classname::createTracker(const classname::Params &parameters){

...

}

That function can (and probably will) return a pointer to some derived class of "classname", which will probably have a real constructor.

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

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 : :

class CV_EXPORTS_W TrackerSamplerCSC : public TrackerSamplerAlgorithm
{
 public:
  TrackerSamplerCSC( const TrackerSamplerCSC::Params &parameters = TrackerSamplerCSC::Params() );
  ~TrackerSamplerCSC();
  ...
 protected:
  bool samplingImpl( const Mat& image, Rect boundingBox, std::vector<Mat>& sample );
  ...
};

Example of adding TrackerSamplerAlgorithm to TrackerSampler : :

//sampler is the TrackerSampler
Ptr<TrackerSamplerAlgorithm> CSCSampler = new TrackerSamplerCSC( CSCparameters );
if( !sampler->addTrackerSamplerAlgorithm( CSCSampler ) )
 return false;
//or add CSC sampler with default parameters
//sampler->addTrackerSamplerAlgorithm( "CSC" );

See also: TrackerSamplerCSC, TrackerSamplerAlgorithm

TrackerFeatureSet

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 : :

class CV_EXPORTS_W TrackerFeatureHAAR : public TrackerFeature
{
 public:
  TrackerFeatureHAAR( const TrackerFeatureHAAR::Params &parameters = TrackerFeatureHAAR::Params() );
  ~TrackerFeatureHAAR();
  void selection( Mat& response, int npoints );
  ...
 protected:
  bool computeImpl( const std::vector<Mat>& images, Mat& response );
  ...
};

Example of adding TrackerFeature to TrackerFeatureSet : :

//featureSet is the TrackerFeatureSet
Ptr<TrackerFeature> trackerFeature = new TrackerFeatureHAAR( HAARparameters );
featureSet->addTrackerFeature( trackerFeature );

See also: TrackerFeatureHAAR, TrackerFeatureSet

TrackerModel

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 [124] table I (ME) for further information. Fill "modelUpdateImpl" in order to update the model, see [124] 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 : :

class TrackerMILModel : public TrackerModel
{
 public:
  TrackerMILModel( const Rect& boundingBox );
  ~TrackerMILModel();
  ...
 protected:
  void modelEstimationImpl( const std::vector<Mat>& responses );
  void modelUpdateImpl();
  ...
};

And add it in your Tracker : :

bool TrackerMIL::initImpl( const Mat& image, const Rect2d& boundingBox )
{
  ...
  //model is the general TrackerModel field of the general Tracker
  model = new TrackerMILModel( boundingBox );
  ...
}

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 : :

class CV_EXPORTS_W TrackerStateEstimatorMILBoosting : public TrackerStateEstimator
{
 class TrackerMILTargetState : public TrackerTargetState
 {
 ...
 };
 public:
  TrackerStateEstimatorMILBoosting( int nFeatures = 250 );
  ~TrackerStateEstimatorMILBoosting();
  ...
 protected:
  Ptr<TrackerTargetState> estimateImpl( const std::vector<ConfidenceMap>& confidenceMaps );
  void updateImpl( std::vector<ConfidenceMap>& confidenceMaps );
  ...
};

And add it in your TrackerModel : :

//model is the TrackerModel of your Tracker
Ptr<TrackerStateEstimatorMILBoosting> stateEstimator = new TrackerStateEstimatorMILBoosting( params.featureSetNumFeatures );
model->setTrackerStateEstimator( stateEstimator );

See also: TrackerModel, TrackerStateEstimatorMILBoosting, TrackerTargetState

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 : :

class TrackerMILTargetState : public TrackerTargetState
{
 public:
  TrackerMILTargetState( const Point2f& position, int targetWidth, int targetHeight, bool foreground, const Mat& features );
  ~TrackerMILTargetState();
  ...
 private:
  bool isTarget;
  Mat targetFeatures;
  ...
};

Try it

To try your tracker you can use the demo at https://github.com/lenlen/opencv/blob/tracking_api/samples/cpp/tracker.cpp.

The first argument is the name of the tracker and the second is a video source.

Macro Definition Documentation

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

Value:

/* (x, y) */                                                          \
    (p0) = (rect).x + (step) * (rect).y;                                  \
    /* (x + w, y) */                                                      \
    (p1) = (rect).x + (rect).width + (step) * (rect).y;                   \
    /* (x + w, y) */                                                      \
    (p2) = (rect).x + (step) * ((rect).y + (rect).height);                \
    /* (x + w, y + h) */                                                  \
    (p3) = (rect).x + (rect).width + (step) * ((rect).y + (rect).height);

#define CV_TILTED_OFFSETS	(	p0,
		p1,
		p2,
		p3,
		rect,
		step
	)

Value:

/* (x, y) */                                                          \
    (p0) = (rect).x + (step) * (rect).y;                                  \
    /* (x - h, y + h) */                                                  \
    (p1) = (rect).x - (rect).height + (step) * ((rect).y + (rect).height);\
    /* (x + w, y + w) */                                                  \
    (p2) = (rect).x + (rect).width + (step) * ((rect).y + (rect).width);  \
    /* (x + w - h, y + w + h) */                                          \
    (p3) = (rect).x + (rect).width - (rect).height                        \
           + (step) * ((rect).y + (rect).width + (rect).height);

#define FEATURES "features"

#define HFP_NAME "haarFeatureParams"

#define HOGF_NAME "HOGFeatureParams"

#define LBPF_NAME "lbpFeatureParams"

#define N_BINS 9

#define N_CELLS 4

#define sign ( s ) ((s > 0 ) ? 1 : ((s<0) ? -1 : 0))

Typedef Documentation

typedef std::vector<std::pair<Ptr<TrackerTargetState>, float> > cv::ConfidenceMap

Represents the model of the target at frame \(k\) (all states and scores)

See [124] The set of the pair \(\langle \hat{x}^{i}_{k}, C^{i}_{k} \rangle\)

See also: TrackerTargetState

typedef std::vector<Ptr<TrackerTargetState> > cv::Trajectory

Represents the estimate states for all frames.

[124] \(x_{k}\) is the trajectory of the target up to time \(k\)

See also: TrackerTargetState

Enumeration Type Documentation

anonymous enum

Enumerator
HAAR
LBP
HOG

anonymous enum

Enumerator
MODE_INIT_POS	mode for init positive samples
MODE_INIT_NEG	mode for init negative samples
MODE_TRACK_POS	mode for update positive samples
MODE_TRACK_NEG	mode for update negative samples
MODE_DETECT	mode for detect samples

anonymous enum

Enumerator
MODE_POSITIVE	mode for positive samples
MODE_NEGATIVE	mode for negative samples
MODE_CLASSIFY	mode for classify samples

enum cv::TrackerKCF::MODE

Feature type to be used in the tracking grayscale, colornames, compressed color-names The modes available now:

"GRAY" – Use grayscale values as the feature
"CN" – Color-names feature

Enumerator
GRAY
CN
CUSTOM

Function Documentation

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

inline

uchar cv::CvLBPEvaluator::Feature::calc	(	const Mat &	_sum,
		size_t	y
	)		const

inline

float cv::calcNormFactor	(	const Mat &	sum,
		const Mat &	sqSum
	)

float cv::CvHOGEvaluator::operator()	(	int	varIdx,
		int	sampleIdx
	)

inlinevirtual

Implements cv::CvFeatureEvaluator.

Rect2d cv::selectROI	(	Mat	img,
		bool	fromCenter = `true`
	)

Rect2d cv::selectROI	(	const cv::String &	windowName,
		Mat	img,
		bool	showCrossair = `true`,
		bool	fromCenter = `true`
	)

void cv::selectROI	(	const cv::String &	windowName,
		Mat	img,
		std::vector< Rect2d > &	boundingBox,
		bool	fromCenter = `true`
	)

Classes

Macros

Typedefs

Enumerations

Functions

Detailed Description

Long-term optical tracking API

Creating Own Tracker

TrackerSampler

TrackerFeatureSet

TrackerModel

Try it

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation