From 9e30b50d264b00e34be02890d6a9fc00366d5572 Mon Sep 17 00:00:00 2001
From: Antonella Cascitelli <antonellacascitelli@gmail.com>
Date: Thu, 19 Sep 2013 18:27:49 +0200
Subject: [PATCH] Added tracking module
Modified Copyrights
Moved plantuml source files under doc
disabled tests
Added include of precomp.hpp
---
modules/tracking/CMakeLists.txt | 2 +
.../doc/common_interfaces_tracker.rst | 264 ++++
.../common_interfaces_tracker_feature_set.rst | 343 ++++++
.../doc/common_interfaces_tracker_model.rst | 506 ++++++++
.../doc/common_interfaces_tracker_sampler.rst | 293 +++++
modules/tracking/doc/misc/Tracker.txt | 43 +
modules/tracking/doc/misc/TrackerFeature.txt | 55 +
modules/tracking/doc/misc/TrackerModel.txt | 62 +
modules/tracking/doc/misc/TrackerSampler.txt | 44 +
modules/tracking/doc/misc/packages.txt | 19 +
modules/tracking/doc/pics/Tracker.png | Bin 0 -> 32315 bytes
modules/tracking/doc/pics/TrackerFeature.png | Bin 0 -> 60096 bytes
modules/tracking/doc/pics/TrackerModel.png | Bin 0 -> 57820 bytes
modules/tracking/doc/pics/TrackerSampler.png | Bin 0 -> 48429 bytes
modules/tracking/doc/pics/package.png | Bin 0 -> 8746 bytes
modules/tracking/doc/tracker_algorithms.rst | 121 ++
modules/tracking/doc/tracking.rst | 86 ++
modules/tracking/include/opencv2/tracking.hpp | 52 +
.../include/opencv2/tracking/feature.hpp | 410 +++++++
.../opencv2/tracking/onlineBoosting.hpp | 282 +++++
.../include/opencv2/tracking/onlineMIL.hpp | 114 ++
.../include/opencv2/tracking/tracker.hpp | 1021 ++++++++++++++++
.../include/opencv2/tracking/tracking.hpp | 46 +
modules/tracking/perf/perf_main.cpp | 3 +
modules/tracking/perf/perf_precomp.hpp | 21 +
modules/tracking/perf/perf_tracking.cpp | 46 +
modules/tracking/samples/tracker.cpp | 148 +++
modules/tracking/src/feature.cpp | 1072 +++++++++++++++++
modules/tracking/src/onlineBoosting.cpp | 735 +++++++++++
modules/tracking/src/onlineMIL.cpp | 379 ++++++
modules/tracking/src/precomp.hpp | 49 +
modules/tracking/src/tracker.cpp | 107 ++
modules/tracking/src/trackerBoosting.cpp | 308 +++++
modules/tracking/src/trackerBoostingModel.cpp | 123 ++
modules/tracking/src/trackerBoostingModel.hpp | 109 ++
modules/tracking/src/trackerFeature.cpp | 325 +++++
modules/tracking/src/trackerFeatureSet.cpp | 142 +++
modules/tracking/src/trackerMIL.cpp | 273 +++++
modules/tracking/src/trackerMILModel.cpp | 126 ++
modules/tracking/src/trackerMILModel.hpp | 103 ++
modules/tracking/src/trackerModel.cpp | 178 +++
modules/tracking/src/trackerSampler.cpp | 142 +++
.../tracking/src/trackerSamplerAlgorithm.cpp | 382 ++++++
.../tracking/src/trackerStateEstimator.cpp | 445 +++++++
modules/tracking/src/tracking_init.cpp | 61 +
modules/tracking/test/test_main.cpp | 3 +
modules/tracking/test/test_precomp.hpp | 18 +
modules/tracking/test/test_tracker.cpp | 130 ++
48 files changed, 9191 insertions(+)
create mode 100644 modules/tracking/CMakeLists.txt
create mode 100644 modules/tracking/doc/common_interfaces_tracker.rst
create mode 100644 modules/tracking/doc/common_interfaces_tracker_feature_set.rst
create mode 100644 modules/tracking/doc/common_interfaces_tracker_model.rst
create mode 100644 modules/tracking/doc/common_interfaces_tracker_sampler.rst
create mode 100644 modules/tracking/doc/misc/Tracker.txt
create mode 100644 modules/tracking/doc/misc/TrackerFeature.txt
create mode 100644 modules/tracking/doc/misc/TrackerModel.txt
create mode 100644 modules/tracking/doc/misc/TrackerSampler.txt
create mode 100644 modules/tracking/doc/misc/packages.txt
create mode 100644 modules/tracking/doc/pics/Tracker.png
create mode 100644 modules/tracking/doc/pics/TrackerFeature.png
create mode 100644 modules/tracking/doc/pics/TrackerModel.png
create mode 100644 modules/tracking/doc/pics/TrackerSampler.png
create mode 100644 modules/tracking/doc/pics/package.png
create mode 100644 modules/tracking/doc/tracker_algorithms.rst
create mode 100644 modules/tracking/doc/tracking.rst
create mode 100644 modules/tracking/include/opencv2/tracking.hpp
create mode 100644 modules/tracking/include/opencv2/tracking/feature.hpp
create mode 100644 modules/tracking/include/opencv2/tracking/onlineBoosting.hpp
create mode 100644 modules/tracking/include/opencv2/tracking/onlineMIL.hpp
create mode 100644 modules/tracking/include/opencv2/tracking/tracker.hpp
create mode 100644 modules/tracking/include/opencv2/tracking/tracking.hpp
create mode 100644 modules/tracking/perf/perf_main.cpp
create mode 100644 modules/tracking/perf/perf_precomp.hpp
create mode 100644 modules/tracking/perf/perf_tracking.cpp
create mode 100644 modules/tracking/samples/tracker.cpp
create mode 100644 modules/tracking/src/feature.cpp
create mode 100644 modules/tracking/src/onlineBoosting.cpp
create mode 100644 modules/tracking/src/onlineMIL.cpp
create mode 100644 modules/tracking/src/precomp.hpp
create mode 100644 modules/tracking/src/tracker.cpp
create mode 100644 modules/tracking/src/trackerBoosting.cpp
create mode 100644 modules/tracking/src/trackerBoostingModel.cpp
create mode 100644 modules/tracking/src/trackerBoostingModel.hpp
create mode 100644 modules/tracking/src/trackerFeature.cpp
create mode 100644 modules/tracking/src/trackerFeatureSet.cpp
create mode 100644 modules/tracking/src/trackerMIL.cpp
create mode 100644 modules/tracking/src/trackerMILModel.cpp
create mode 100644 modules/tracking/src/trackerMILModel.hpp
create mode 100644 modules/tracking/src/trackerModel.cpp
create mode 100644 modules/tracking/src/trackerSampler.cpp
create mode 100644 modules/tracking/src/trackerSamplerAlgorithm.cpp
create mode 100644 modules/tracking/src/trackerStateEstimator.cpp
create mode 100644 modules/tracking/src/tracking_init.cpp
create mode 100644 modules/tracking/test/test_main.cpp
create mode 100644 modules/tracking/test/test_precomp.hpp
create mode 100644 modules/tracking/test/test_tracker.cpp
diff --git a/modules/tracking/CMakeLists.txt b/modules/tracking/CMakeLists.txt
new file mode 100644
index 000000000..39983045b
--- /dev/null
+++ b/modules/tracking/CMakeLists.txt
@@ -0,0 +1,2 @@
+set(the_description "Tracking API")
+ocv_define_module(tracking opencv_imgproc)
diff --git a/modules/tracking/doc/common_interfaces_tracker.rst b/modules/tracking/doc/common_interfaces_tracker.rst
new file mode 100644
index 000000000..049366098
--- /dev/null
+++ b/modules/tracking/doc/common_interfaces_tracker.rst
@@ -0,0 +1,264 @@
+Common Interfaces of Tracker
+============================
+
+.. highlight:: cpp
+
+
+Tracker : Algorithm
+-------------------
+
+.. ocv:class:: Tracker
+
+Base abstract class for the long-term tracker::
+
+ class CV_EXPORTS_W Tracker : public virtual Algorithm
+ {
+ virtual ~Tracker();
+
+ bool init( const Mat& image, const Rect& boundingBox );
+
+ bool update( const Mat& image, Rect& boundingBox );
+
+ static Ptr<Tracker> create( const String& trackerType );
+
+ };
+
+Tracker::init
+-------------
+
+Initialize the tracker with a know bounding box that surrounding the target
+
+.. ocv:function:: bool Tracker::init( const Mat& image, const Rect& boundingBox )
+
+ :param image: The initial frame
+
+ :param boundingBox: The initial boundig box
+
+
+Tracker::update
+---------------
+
+Update the tracker, find the new most likely bounding box for the target
+
+.. ocv:function:: bool Tracker::update( const Mat& image, Rect& boundingBox )
+
+ :param image: The current frame
+
+ :param boundingBox: The boundig box that represent the new target location
+
+
+Tracker::create
+---------------
+
+Creates a tracker by its name.
+
+.. ocv:function:: static Ptr<Tracker> Tracker::create( const String& trackerType )
+
+ :param trackerType: Tracker type
+
+The following detector types are supported:
+
+* ``"MIL"`` -- :ocv:class:`TrackerMIL`
+
+* ``"BOOSTING"`` -- :ocv:class:`TrackerBoosting`
+
+Creating Own Tracker
+--------------------
+
+If you want create a new tracker, you should follow some simple rules.
+
+First, your tracker should be inherit from :ocv:class:`Tracker`, so you must implement two method:
+
+* Tracker: initImpl, it should be called once in the first frame, here you should initialize all structures. The second argument is the initial bounding box of the target.
+
+* Tracker:updateImpl, it should be called at the begin of in loop through video frames. Here you should overwrite the bounding box with new location.
+
+Example of creating specialized Tracker ``TrackerMIL`` : ::
+
+ class CV_EXPORTS_W TrackerMIL : public Tracker
+ {
+ public:
+ TrackerMIL( const TrackerMIL::Params ¶meters = TrackerMIL::Params() );
+ virtual ~TrackerMIL();
+ ...
+
+ protected:
+ bool initImpl( const Mat& image, const Rect& boundingBox );
+ bool updateImpl( const Mat& image, Rect& boundingBox );
+ ...
+ };
+
+
+Every tracker has three component :ocv:class:`TrackerSampler`, :ocv:class:`TrackerFeatureSet` and :ocv:class:`TrackerModel`.
+The first two are instantiated from Tracker base class, instead the last component is abstract, so you must implement your TrackerModel.
+
+Finally add your tracker in the file tracking_init.cpp
+
+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 :ocv:class:`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 ¶meters = 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" );
+
+.. seealso::
+
+ :ocv:class:`TrackerSamplerCSC`, :ocv:class:`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 :ocv:class:`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 ¶meters = 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 );
+
+.. seealso::
+
+ :ocv:class:`TrackerFeatureHAAR`, :ocv:class:`TrackerFeatureSet`
+
+TrackerModel
+............
+
+TrackerModel is abstract, so in your implementation you must develop your TrackerModel that inherit from :ocv:class:`TrackerModel`.
+Fill the method for the estimation of the state "modelEstimationImpl", that estimates the most likely target location,
+see [AAM]_ table I (ME) for further information. Fill "modelUpdateImpl" in order to update the model, see [AAM]_ table I (MU).
+In this class you can use the :c:type:`ConfidenceMap` and :c:type:`Trajectory` 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 Rect& boundingBox )
+ {
+ ...
+ //model is the general TrackerModel field od 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 :ocv:class:`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 );
+
+.. seealso::
+
+ :ocv:class:`TrackerModel`, :ocv:class:`TrackerStateEstimatorMILBoosting`, :ocv:class:`TrackerTargetState`
+
+
+During this step, you should define your TrackerTargetState based on your implementation. :ocv:class:`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.
diff --git a/modules/tracking/doc/common_interfaces_tracker_feature_set.rst b/modules/tracking/doc/common_interfaces_tracker_feature_set.rst
new file mode 100644
index 000000000..2dbfea564
--- /dev/null
+++ b/modules/tracking/doc/common_interfaces_tracker_feature_set.rst
@@ -0,0 +1,343 @@
+Common Interfaces of TrackerFeatureSet
+======================================
+
+.. highlight:: cpp
+
+
+TrackerFeatureSet
+-----------------
+
+Class that manages the extraction and selection of features
+
+[AAM]_ Feature Extraction and Feature Set Refinement (Feature Processing and Feature Selection). See table I and section III C
+[AMVOT]_ Appearance modelling -> Visual representation (Table II, section 3.1 - 3.2)
+
+.. ocv:class:: TrackerFeatureSet
+
+TrackerFeatureSet class::
+
+ class CV_EXPORTS_W TrackerFeatureSet
+ {
+ public:
+
+ TrackerFeatureSet();
+ ~TrackerFeatureSet();
+
+ void extraction( const std::vector<Mat>& images );
+ void selection();
+ void removeOutliers();
+
+ bool addTrackerFeature( String trackerFeatureType );
+ bool addTrackerFeature( Ptr<TrackerFeature>& feature );
+
+ const std::vector<std::pair<String, Ptr<TrackerFeature> > >& getTrackerFeature() const;
+ const std::vector<Mat>& getResponses() const;
+
+ };
+
+
+TrackerFeatureSet is an aggregation of :ocv:class:`TrackerFeature`
+
+.. seealso::
+
+ :ocv:class:`TrackerFeature`
+
+TrackerFeatureSet::extraction
+-----------------------------
+
+Extract features from the images collection
+
+.. ocv:function:: void TrackerFeatureSet::extraction( const std::vector<Mat>& images )
+
+ :param images: The input images
+
+TrackerFeatureSet::selection
+----------------------------
+
+Identify most effective features for all feature types (optional)
+
+.. ocv:function:: void TrackerFeatureSet::selection()
+
+TrackerFeatureSet::removeOutliers
+---------------------------------
+
+Remove outliers for all feature types (optional)
+
+.. ocv:function:: void TrackerFeatureSet::removeOutliers()
+
+TrackerFeatureSet::addTrackerFeature
+------------------------------------
+
+Add TrackerFeature in the collection. Return true if TrackerFeature is added, false otherwise
+
+.. ocv:function:: bool TrackerFeatureSet::addTrackerFeature( String trackerFeatureType )
+
+ :param trackerFeatureType: The TrackerFeature name
+
+.. ocv:function:: bool TrackerFeatureSet::addTrackerFeature( Ptr<TrackerFeature>& feature )
+
+ :param feature: The TrackerFeature class
+
+
+The modes available now:
+
+* ``"HAAR"`` -- Haar Feature-based
+
+The modes available soon:
+
+* ``"HOG"`` -- Histogram of Oriented Gradients features
+
+* ``"LBP"`` -- Local Binary Pattern features
+
+* ``"FEATURE2D"`` -- All types of Feature2D
+
+Example ``TrackerFeatureSet::addTrackerFeature`` : ::
+
+ //sample usage:
+
+ Ptr<TrackerFeature> trackerFeature = new TrackerFeatureHAAR( HAARparameters );
+ featureSet->addTrackerFeature( trackerFeature );
+
+ //or add CSC sampler with default parameters
+ //featureSet->addTrackerFeature( "HAAR" );
+
+
+.. note:: If you use the second method, you must initialize the TrackerFeature
+
+TrackerFeatureSet::getTrackerFeature
+------------------------------------
+
+Get the TrackerFeature collection (TrackerFeature name, TrackerFeature pointer)
+
+.. ocv:function:: const std::vector<std::pair<String, Ptr<TrackerFeature> > >& TrackerFeatureSet::getTrackerFeature() const
+
+TrackerFeatureSet::getResponses
+-------------------------------
+
+Get the responses
+
+.. ocv:function:: const std::vector<Mat>& TrackerFeatureSet::getResponses() const
+
+.. note:: Be sure to call extraction before getResponses
+
+Example ``TrackerFeatureSet::getResponses`` : ::
+
+ //get the patches from sampler
+ std::vector<Mat> detectSamples = sampler->getSamples();
+
+ if( detectSamples.empty() )
+ return false;
+
+ //features extraction
+ featureSet->extraction( detectSamples );
+
+ //get responses
+ std::vector<Mat> response = featureSet->getResponses();
+
+TrackerFeature
+--------------
+
+Abstract base class for TrackerFeature that represents the feature.
+
+.. ocv:class:: TrackerFeature
+
+TrackerFeature class::
+
+ class CV_EXPORTS_W TrackerFeature
+ {
+ public:
+ virtual ~TrackerFeature();
+
+ static Ptr<TrackerFeature> create( const String& trackerFeatureType );
+
+ void compute( const std::vector<Mat>& images, Mat& response );
+
+ virtual void selection( Mat& response, int npoints ) = 0;
+
+ String getClassName() const;
+ };
+
+TrackerFeature::create
+----------------------
+
+Create TrackerFeature by tracker feature type
+
+.. ocv:function:: static Ptr<TrackerFeature> TrackerFeature::create( const String& trackerFeatureType )
+
+ :param trackerFeatureType: The TrackerFeature name
+
+The modes available now:
+
+* ``"HAAR"`` -- Haar Feature-based
+
+The modes available soon:
+
+* ``"HOG"`` -- Histogram of Oriented Gradients features
+
+* ``"LBP"`` -- Local Binary Pattern features
+
+* ``"FEATURE2D"`` -- All types of Feature2D
+
+TrackerFeature::compute
+-----------------------
+
+Compute the features in the images collection
+
+.. ocv:function:: void TrackerFeature::compute( const std::vector<Mat>& images, Mat& response )
+
+ :param images: The images
+
+ :param response: The output response
+
+TrackerFeature::selection
+-------------------------
+
+Identify most effective features
+
+.. ocv:function:: void TrackerFeature::selection( Mat& response, int npoints )
+
+ :param response: Collection of response for the specific TrackerFeature
+
+ :param npoints: Max number of features
+
+.. note:: This method modifies the response parameter
+
+TrackerFeature::getClassName
+----------------------------
+
+Get the name of the specific TrackerFeature
+
+.. ocv:function:: String TrackerFeature::getClassName() const
+
+Specialized TrackerFeature
+==========================
+
+In [AAM]_ table I and section III C are described the most known features type. At moment only :ocv:class:`TrackerFeatureHAAR` is implemented.
+
+TrackerFeatureHAAR : TrackerFeature
+-----------------------------------
+
+TrackerFeature based on HAAR features, used by TrackerMIL and many others algorithms
+
+.. ocv:class:: TrackerFeatureHAAR
+
+TrackerFeatureHAAR class::
+
+ class CV_EXPORTS_W TrackerFeatureHAAR : TrackerFeature
+ {
+ public:
+
+ TrackerFeatureHAAR( const TrackerFeatureHAAR::Params ¶meters = TrackerFeatureHAAR::Params() );
+ ~TrackerFeatureHAAR();
+
+ void selection( Mat& response, int npoints );
+ bool extractSelected( const std::vector<int> selFeatures, const std::vector<Mat>& images, Mat& response );
+ std::vector<std::pair<float, float> >& getMeanSigmaPairs();
+ bool swapFeature( int source, int target );
+ bool swapFeature( int id, CvHaarEvaluator::FeatureHaar& feature );
+ CvHaarEvaluator::FeatureHaar& getFeatureAt( int id );
+ };
+
+.. note:: HAAR features implementation is copied from apps/traincascade and modified according to MIL implementation
+
+TrackerFeatureHAAR::Params
+--------------------------
+
+.. ocv:struct:: TrackerFeatureHAAR::Params
+
+List of TrackerFeatureHAAR parameters::
+
+ struct CV_EXPORTS Params
+ {
+ Params();
+ int numFeatures; // # of rects
+ Size rectSize; // rect size
+ bool isIntegral; // true if input images are integral, false otherwise
+ };
+
+TrackerFeatureHAAR::TrackerFeatureHAAR
+--------------------------------------
+
+Constructor
+
+.. ocv:function:: TrackerFeatureHAAR::TrackerFeatureHAAR( const TrackerFeatureHAAR::Params ¶meters = TrackerFeatureHAAR::Params() )
+
+ :param parameters: TrackerFeatureHAAR parameters :ocv:struct:`TrackerFeatureHAAR::Params`
+
+
+TrackerFeatureHAAR::selection
+-----------------------------
+
+Identify most effective features
+
+.. ocv:function:: void TrackerFeatureHAAR::selection( Mat& response, int npoints )
+
+ :param response: Collection of response for the specific TrackerFeature
+
+ :param npoints: Max number of features
+
+.. note:: This method modifies the response parameter
+
+TrackerFeatureHAAR::extractSelected
+-----------------------------------
+
+Compute the features only for the selected indices in the images collection
+
+.. ocv:function:: bool TrackerFeatureHAAR::extractSelected( const std::vector<int> selFeatures, const std::vector<Mat>& images, Mat& response )
+
+ :param selFeatures: indices of selected features
+
+ :param images: The images
+
+ :param response: Collection of response for the specific TrackerFeature
+
+TrackerFeatureHAAR::getMeanSigmaPairs
+-------------------------------------
+
+Get the list of mean/sigma. Return the list of mean/sigma
+
+.. ocv:function:: std::vector<std::pair<float, float> >& TrackerFeatureHAAR::getMeanSigmaPairs()
+
+TrackerFeatureHAAR::swapFeature
+-------------------------------
+
+Swap the feature in position source with the feature in position target
+
+.. ocv:function:: bool TrackerFeatureHAAR::swapFeature( int source, int target )
+
+ :param source: The source position
+
+ :param target: The target position
+
+Swap the feature in position id with the feature input
+
+.. ocv:function:: bool TrackerFeatureHAAR::swapFeature( int id, CvHaarEvaluator::FeatureHaar& feature )
+
+ :param id: The position
+
+ :param feature: The feature
+
+TrackerFeatureHAAR::getFeatureAt
+--------------------------------
+
+Get the feature in position id
+
+.. ocv:function:: CvHaarEvaluator::FeatureHaar& TrackerFeatureHAAR::getFeatureAt( int id )
+
+ :param id: The position
+
+
+TrackerFeatureHOG
+-----------------
+
+TODO To be implemented
+
+TrackerFeatureLBP
+-----------------
+
+TODO To be implemented
+
+TrackerFeatureFeature2d
+-----------------------
+
+TODO To be implemented
diff --git a/modules/tracking/doc/common_interfaces_tracker_model.rst b/modules/tracking/doc/common_interfaces_tracker_model.rst
new file mode 100644
index 000000000..ef0696f0d
--- /dev/null
+++ b/modules/tracking/doc/common_interfaces_tracker_model.rst
@@ -0,0 +1,506 @@
+Common Interfaces of TrackerModel
+=================================
+
+.. highlight:: cpp
+
+ConfidenceMap
+-------------
+
+Represents the model of the target at frame :math:`k` (all states and scores)
+
+[AAM]_ The set of the pair :math:`\langle \hat{x}^{i}_{k}, C^{i}_{k} \rangle`
+
+.. c:type:: ConfidenceMap
+
+ConfidenceMap::
+
+ typedef std::vector<std::pair<Ptr<TrackerTargetState>, float> > ConfidenceMap;
+
+.. seealso::
+
+ :ocv:class:`TrackerTargetState`
+
+Trajectory
+----------
+
+Represents the estimate states for all frames
+
+[AAM]_ :math:`x_{k}` is the trajectory of the target up to time :math:`k`
+
+.. c:type:: Trajectory
+
+Trajectory::
+
+ typedef std::vector<Ptr<TrackerTargetState> > Trajectory;
+
+.. seealso::
+
+ :ocv:class:`TrackerTargetState`
+
+TrackerTargetState
+------------------
+
+Abstract base class for TrackerTargetState that represents a possible state of the target.
+
+[AAM]_ :math:`\hat{x}^{i}_{k}` all the states candidates.
+
+Inherits this class with your Target state
+
+.. ocv:class:: TrackerTargetState
+
+TrackerTargetState class::
+
+ class CV_EXPORTS_W TrackerTargetState
+ {
+ public:
+ virtual ~TrackerTargetState(){};
+
+ Point2f getTargetPosition() const;
+ void setTargetPosition( const Point2f& position );
+
+ int getTargetWidth() const;
+ void setTargetWidth( int width );
+
+ int getTargetHeight() const;
+ void setTargetHeight( int height );
+
+ };
+
+In own implementation you can add scale variation, width, height, orientation, etc.
+
+
+TrackerStateEstimator
+---------------------
+
+Abstract base class for TrackerStateEstimator that estimates the most likely target state.
+
+[AAM]_ State estimator
+
+[AMVOT]_ Statistical modeling (Fig. 3), Table III (generative) - IV (discriminative) - V (hybrid)
+
+.. ocv:class:: TrackerStateEstimator
+
+TrackerStateEstimator class::
+
+ class CV_EXPORTS_W TrackerStateEstimator
+ {
+ public:
+ virtual ~TrackerStateEstimator();
+
+ static Ptr<TrackerStateEstimator> create( const String& trackeStateEstimatorType );
+
+ Ptr<TrackerTargetState> estimate( const std::vector<ConfidenceMap>& confidenceMaps );
+ void update( std::vector<ConfidenceMap>& confidenceMaps );
+
+ String getClassName() const;
+
+ };
+
+TrackerStateEstimator::create
+-----------------------------
+
+Create TrackerStateEstimator by tracker state estimator type
+
+.. ocv:function:: static Ptr<TrackerStateEstimator> TrackerStateEstimator::create( const String& trackeStateEstimatorType )
+
+ :param trackeStateEstimatorType: The TrackerStateEstimator name
+
+The modes available now:
+
+* ``"BOOSTING"`` -- Boosting-based discriminative appearance models. See [AMVOT]_ section 4.4
+
+The modes available soon:
+
+* ``"SVM"`` -- SVM-based discriminative appearance models. See [AMVOT]_ section 4.5
+
+TrackerStateEstimator::estimate
+-------------------------------
+
+Estimate the most likely target state, return the estimated state
+
+.. ocv:function:: Ptr<TrackerTargetState> TrackerStateEstimator::estimate( const std::vector<ConfidenceMap>& confidenceMaps )
+
+ :param confidenceMaps: The overall appearance model as a list of :c:type:`ConfidenceMap`
+
+TrackerStateEstimator::update
+-----------------------------
+
+Update the ConfidenceMap with the scores
+
+.. ocv:function:: void TrackerStateEstimator::update( std::vector<ConfidenceMap>& confidenceMaps )
+
+ :param confidenceMaps: The overall appearance model as a list of :c:type:`ConfidenceMap`
+
+TrackerStateEstimator::getClassName
+-----------------------------------
+
+Get the name of the specific TrackerStateEstimator
+
+.. ocv:function:: String TrackerStateEstimator::getClassName() const
+
+TrackerModel
+------------
+
+Abstract class that represents the model of the target. It must be instantiated by specialized tracker
+
+[AAM]_ Ak
+
+Inherits this with your TrackerModel
+
+.. ocv:class:: TrackerModel
+
+TrackerModel class::
+
+ class CV_EXPORTS_W TrackerModel
+ {
+ public:
+
+ TrackerModel();
+ virtual ~TrackerModel();
+
+ void modelEstimation( const std::vector<Mat>& responses );
+ void modelUpdate();
+ bool runStateEstimator();
+
+ bool setTrackerStateEstimator( Ptr<TrackerStateEstimator> trackerStateEstimator );
+ void setLastTargetState( const Ptr<TrackerTargetState>& lastTargetState );
+
+ Ptr<TrackerTargetState> getLastTargetState() const;
+ const std::vector<ConfidenceMap>& getConfidenceMaps() const;
+ const ConfidenceMap& getLastConfidenceMap() const;
+ Ptr<TrackerStateEstimator> getTrackerStateEstimator() const;
+ };
+
+TrackerModel::modelEstimation
+-----------------------------
+
+Estimate the most likely target location
+
+[AAM]_ ME, Model Estimation table I
+
+.. ocv:function:: void TrackerModel::modelEstimation( const std::vector<Mat>& responses )
+
+ :param responses: Features extracted from :ocv:class:`TrackerFeatureSet`
+
+
+TrackerModel::modelUpdate
+-------------------------
+
+Update the model
+
+[AAM]_ MU, Model Update table I
+
+.. ocv:function:: void TrackerModel::modelUpdate()
+
+
+TrackerModel::runStateEstimator
+-------------------------------
+
+Run the TrackerStateEstimator, return true if is possible to estimate a new state, false otherwise
+
+.. ocv:function:: bool TrackerModel::runStateEstimator()
+
+TrackerModel::setTrackerStateEstimator
+--------------------------------------
+
+Set TrackerEstimator, return true if the tracker state estimator is added, false otherwise
+
+.. ocv:function:: bool TrackerModel::setTrackerStateEstimator( Ptr<TrackerStateEstimator> trackerStateEstimator )
+
+ :param trackerStateEstimator: The :ocv:class:`TrackerStateEstimator`
+
+.. note:: You can add only one :ocv:class:`TrackerStateEstimator`
+
+TrackerModel::setLastTargetState
+--------------------------------
+
+Set the current :ocv:class:`TrackerTargetState` in the :c:type:`Trajectory`
+
+.. ocv:function:: void TrackerModel::setLastTargetState( const Ptr<TrackerTargetState>& lastTargetState )
+
+ :param lastTargetState: The current :ocv:class:`TrackerTargetState`
+
+
+TrackerModel::getLastTargetState
+--------------------------------
+
+Get the last :ocv:class:`TrackerTargetState` from :c:type:`Trajectory`
+
+.. ocv:function:: Ptr<TrackerTargetState> TrackerModel::getLastTargetState() const
+
+
+TrackerModel::getConfidenceMaps
+-------------------------------
+
+Get the list of the :c:type:`ConfidenceMap`
+
+.. ocv:function:: const std::vector<ConfidenceMap>& TrackerModel::getConfidenceMaps() const
+
+TrackerModel::getLastConfidenceMap
+----------------------------------
+
+Get the last :c:type:`ConfidenceMap` for the current frame
+
+.. ocv:function:: const ConfidenceMap& TrackerModel::getLastConfidenceMap() const
+
+TrackerModel::getTrackerStateEstimator
+--------------------------------------
+
+Get the :ocv:class:`TrackerStateEstimator`
+
+.. ocv:function:: Ptr<TrackerStateEstimator> TrackerModel::getTrackerStateEstimator() const
+
+Specialized TrackerStateEstimator
+=================================
+
+In [AMVOT]_ Statistical modeling (Fig. 3), Table III (generative) - IV (discriminative) - V (hybrid) are described the most known statistical model.
+
+At moment :ocv:class:`TrackerStateEstimatorMILBoosting` and :ocv:class:`TrackerStateEstimatorAdaBoosting` are implemented.
+
+TrackerStateEstimatorMILBoosting : TrackerStateEstimator
+--------------------------------------------------------
+
+TrackerStateEstimator based on Boosting
+
+.. ocv:class:: TrackerStateEstimatorMILBoosting
+
+TrackerStateEstimatorMILBoosting class::
+
+ class CV_EXPORTS_W TrackerStateEstimatorMILBoosting : public TrackerStateEstimator
+ {
+ public:
+ class TrackerMILTargetState : public TrackerTargetState
+ {
+ ...
+ };
+ TrackerStateEstimatorMILBoosting( int nFeatures = 250 );
+ ~TrackerStateEstimatorMILBoosting();
+
+ void setCurrentConfidenceMap( ConfidenceMap& confidenceMap );
+ };
+
+TrackerMILTargetState : TrackerTargetState
+------------------------------------------
+
+Implementation of the target state for TrackerMILTargetState
+
+.. ocv:class:: TrackerMILTargetState
+
+TrackerMILTargetState class::
+
+ class TrackerMILTargetState : public TrackerTargetState
+ {
+ public:
+ TrackerMILTargetState( const Point2f& position, int targetWidth, int targetHeight, bool foreground, const Mat& features );
+ ~TrackerMILTargetState(){};
+
+ void setTargetFg( bool foreground );
+ void setFeatures( const Mat& features );
+ bool isTargetFg() const;
+ Mat getFeatures() const;
+ };
+
+TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setTargetFg
+--------------------------------------------------------------------
+
+Set label: true for target foreground, false for background
+
+.. ocv:function:: void TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setTargetFg( bool foreground )
+
+ :param foreground: Label for background/foreground
+
+TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setFeatures
+--------------------------------------------------------------------
+
+Set the features extracted from :ocv:class:`TrackerFeatureSet`
+
+.. ocv:function:: void TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setFeatures( const Mat& features )
+
+ :param features: The features extracted
+
+TrackerStateEstimatorMILBoosting::TrackerMILTargetState::isTargetFg
+-------------------------------------------------------------------
+
+Get the label. Return true for target foreground, false for background
+
+.. ocv:function:: bool TrackerStateEstimatorMILBoosting::TrackerMILTargetState::isTargetFg() const
+
+TrackerStateEstimatorMILBoosting::TrackerMILTargetState::getFeatures
+--------------------------------------------------------------------
+
+Get the features extracted
+
+.. ocv:function:: void TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setFeatures( const Mat& features )
+
+TrackerStateEstimatorMILBoosting::TrackerStateEstimatorMILBoosting
+------------------------------------------------------------------
+
+Constructor
+
+.. ocv:function:: TrackerStateEstimatorMILBoosting::TrackerStateEstimatorMILBoosting( int nFeatures=250 )
+
+ :param nFeatures: Number of features for each sample
+
+TrackerStateEstimatorMILBoosting::setCurrentConfidenceMap
+---------------------------------------------------------
+
+Set the current confidenceMap
+
+.. ocv:function:: void TrackerStateEstimatorMILBoosting::setCurrentConfidenceMap( ConfidenceMap& confidenceMap )
+
+ :param confidenceMap: The current :c:type:`ConfidenceMap`
+
+TrackerStateEstimatorAdaBoosting : TrackerStateEstimator
+--------------------------------------------------------
+
+TrackerStateEstimatorAdaBoosting based on ADA-Boosting
+
+.. ocv:class:: TrackerStateEstimatorAdaBoosting
+
+TrackerStateEstimatorAdaBoosting class::
+
+ class CV_EXPORTS_W TrackerStateEstimatorAdaBoosting : public TrackerStateEstimator
+ {
+ public:
+ class TrackerAdaBoostingTargetState : public TrackerTargetState
+ {
+ ...
+ };
+ TrackerStateEstimatorAdaBoosting( int numClassifer, int initIterations, int nFeatures, Size patchSize, const Rect& ROI, const std::vector<std::pair<float, float> >& meanSigma );
+ ~TrackerStateEstimatorAdaBoosting();
+
+ Rect getSampleROI() const;
+ void setSampleROI( const Rect& ROI );
+ void setCurrentConfidenceMap( ConfidenceMap& confidenceMap );
+ std::vector<int> computeSelectedWeakClassifier();
+ std::vector<int> computeReplacedClassifier();
+ std::vector<int> computeSwappedClassifier();
+ void setMeanSigmaPair( const std::vector<std::pair<float, float> >& meanSigmaPair );
+ };
+
+TrackerAdaBoostingTargetState : TrackerTargetState
+--------------------------------------------------
+
+Implementation of the target state for TrackerAdaBoostingTargetState
+
+.. ocv:class:: TrackerAdaBoostingTargetState
+
+TrackerAdaBoostingTargetState class::
+
+ class TrackerAdaBoostingTargetState : public TrackerTargetState
+ {
+ public:
+ TrackerAdaBoostingTargetState( const Point2f& position, int width, int height, bool foreground, const Mat& responses );
+ ~TrackerAdaBoostingTargetState(){};
+
+ void setTargetResponses( const Mat& responses );
+ void setTargetFg( bool foreground );
+ Mat getTargetResponses() const;
+ bool isTargetFg() const;
+ };
+
+TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::setTargetFg
+----------------------------------------------------------------------------
+
+Set label: true for target foreground, false for background
+
+.. ocv:function:: void TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::setTargetFg( bool foreground )
+
+ :param foreground: Label for background/foreground
+
+TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::setTargetResponses
+-----------------------------------------------------------------------------------
+
+Set the features extracted from :ocv:class:`TrackerFeatureSet`
+
+.. ocv:function:: void TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::setTargetResponses( const Mat& responses )
+
+ :param responses: The features extracted
+
+TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::isTargetFg
+---------------------------------------------------------------------------
+
+Get the label. Return true for target foreground, false for background
+
+.. ocv:function:: bool TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::isTargetFg() const
+
+TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::getTargetResponses
+-----------------------------------------------------------------------------------
+
+Get the features extracted
+
+.. ocv:function:: Mat TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::getTargetResponses()
+
+TrackerStateEstimatorAdaBoosting::TrackerStateEstimatorAdaBoosting
+------------------------------------------------------------------
+
+Constructor
+
+.. ocv:function:: TrackerStateEstimatorAdaBoosting::TrackerStateEstimatorAdaBoosting( int numClassifer, int initIterations, int nFeatures, Size patchSize, const Rect& ROI, const std::vector<std::pair<float, float> >& meanSigma )
+
+ :param numClassifer: Number of base classifiers
+
+ :param initIterations: Number of iterations in the initialization
+
+ :param nFeatures: Number of features/weak classifiers
+
+ :param patchSize: tracking rect
+
+ :param ROI: initial ROI
+
+ :param meanSigma: pairs of mean/sigma
+
+TrackerStateEstimatorAdaBoosting::setCurrentConfidenceMap
+---------------------------------------------------------
+
+Set the current confidenceMap
+
+.. ocv:function:: void TrackerStateEstimatorAdaBoosting::setCurrentConfidenceMap( ConfidenceMap& confidenceMap )
+
+ :param confidenceMap: The current :c:type:`ConfidenceMap`
+
+TrackerStateEstimatorAdaBoosting::getSampleROI
+----------------------------------------------
+
+Get the sampling ROI
+
+.. ocv:function:: Rect TrackerStateEstimatorAdaBoosting::getSampleROI() const
+
+TrackerStateEstimatorAdaBoosting::setSampleROI
+----------------------------------------------
+
+Set the sampling ROI
+
+.. ocv:function:: void TrackerStateEstimatorAdaBoosting::setSampleROI( const Rect& ROI )
+
+ :param ROI: the sampling ROI
+
+TrackerStateEstimatorAdaBoosting::computeSelectedWeakClassifier
+---------------------------------------------------------------
+
+Get the list of the selected weak classifiers for the classification step
+
+.. ocv:function:: std::vector<int> TrackerStateEstimatorAdaBoosting::computeSelectedWeakClassifier()
+
+TrackerStateEstimatorAdaBoosting::computeReplacedClassifier
+-----------------------------------------------------------
+
+Get the list of the weak classifiers that should be replaced
+
+.. ocv:function:: std::vector<int> TrackerStateEstimatorAdaBoosting::computeReplacedClassifier()
+
+TrackerStateEstimatorAdaBoosting::computeSwappedClassifier
+----------------------------------------------------------
+
+Get the list of the weak classifiers that replace those to be replaced
+
+.. ocv:function:: std::vector<int> TrackerStateEstimatorAdaBoosting::computeSwappedClassifier()
+
+TrackerStateEstimatorAdaBoosting::setMeanSigmaPair
+--------------------------------------------------
+
+Set the mean/sigma to instantiate possibly new classifiers
+
+.. ocv:function:: void TrackerStateEstimatorAdaBoosting::setMeanSigmaPair( const std::vector<std::pair<float, float> >& meanSigmaPair )
+
+ :param meanSigmaPair: the mean/sigma pairs
diff --git a/modules/tracking/doc/common_interfaces_tracker_sampler.rst b/modules/tracking/doc/common_interfaces_tracker_sampler.rst
new file mode 100644
index 000000000..5355508cb
--- /dev/null
+++ b/modules/tracking/doc/common_interfaces_tracker_sampler.rst
@@ -0,0 +1,293 @@
+Common Interfaces of TrackerSampler
+===================================
+
+.. highlight:: cpp
+
+
+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
+
+.. ocv:class:: TrackerSampler
+
+TrackerSampler class::
+
+ class CV_EXPORTS_W TrackerSampler
+ {
+ public:
+
+ TrackerSampler();
+ ~TrackerSampler();
+
+ void sampling( const Mat& image, Rect boundingBox );
+
+ const std::vector<std::pair<String, Ptr<TrackerSamplerAlgorithm> > >& getSamplers() const;
+ const std::vector<Mat>& getSamples() const;
+
+ bool addTrackerSamplerAlgorithm( String trackerSamplerAlgorithmType );
+ bool addTrackerSamplerAlgorithm( Ptr<TrackerSamplerAlgorithm>& sampler );
+
+ };
+
+
+TrackerSampler is an aggregation of :ocv:class:`TrackerSamplerAlgorithm`
+
+.. seealso::
+
+ :ocv:class:`TrackerSamplerAlgorithm`
+
+TrackerSampler::sampling
+------------------------
+
+Computes the regions starting from a position in an image
+
+.. ocv:function:: void TrackerSampler::sampling( const Mat& image, Rect boundingBox )
+
+ :param image: The current frame
+
+ :param boundingBox: The bounding box from which regions can be calculated
+
+
+TrackerSampler::getSamplers
+---------------------------
+
+Return the collection of the :ocv:class:`TrackerSamplerAlgorithm`
+
+.. ocv:function:: const std::vector<std::pair<String, Ptr<TrackerSamplerAlgorithm> > >& TrackerSampler::getSamplers() const
+
+
+TrackerSampler::getSamples
+--------------------------
+
+Return the samples from all :ocv:class:`TrackerSamplerAlgorithm`, [AAM]_ Fig. 1 variable Sk
+
+.. ocv:function:: const std::vector<Mat>& TrackerSampler::getSamples() const
+
+TrackerSampler::addTrackerSamplerAlgorithm
+------------------------------------------
+
+Add TrackerSamplerAlgorithm in the collection.
+Return true if sampler is added, false otherwise
+
+.. ocv:function:: bool TrackerSampler::addTrackerSamplerAlgorithm( String trackerSamplerAlgorithmType )
+
+ :param trackerSamplerAlgorithmType: The TrackerSamplerAlgorithm name
+
+.. ocv:function:: bool TrackerSampler::addTrackerSamplerAlgorithm( Ptr<TrackerSamplerAlgorithm>& sampler )
+
+ :param sampler: The TrackerSamplerAlgorithm class
+
+
+The modes available now:
+
+* ``"CSC"`` -- Current State Center
+
+* ``"CS"`` -- Current State
+
+Example ``TrackerSamplerAlgorithm::addTrackerSamplerAlgorithm`` : ::
+
+ //sample usage:
+
+ TrackerSamplerCSC::Params CSCparameters;
+ Ptr<TrackerSamplerAlgorithm> CSCSampler = new TrackerSamplerCSC( CSCparameters );
+
+ if( !sampler->addTrackerSamplerAlgorithm( CSCSampler ) )
+ return false;
+
+ //or add CSC sampler with default parameters
+ //sampler->addTrackerSamplerAlgorithm( "CSC" );
+
+
+.. note:: If you use the second method, you must initialize the TrackerSamplerAlgorithm
+
+
+TrackerSamplerAlgorithm
+-----------------------
+
+Abstract base class for TrackerSamplerAlgorithm that represents the algorithm for the specific sampler.
+
+.. ocv:class:: TrackerSamplerAlgorithm
+
+TrackerSamplerAlgorithm class::
+
+ class CV_EXPORTS_W TrackerSamplerAlgorithm
+ {
+ public:
+
+ virtual ~TrackerSamplerAlgorithm();
+
+ static Ptr<TrackerSamplerAlgorithm> create( const String& trackerSamplerType );
+
+ bool sampling( const Mat& image, Rect boundingBox, std::vector<Mat>& sample );
+ String getClassName() const;
+ };
+
+TrackerSamplerAlgorithm::create
+-------------------------------
+
+Create TrackerSamplerAlgorithm by tracker sampler type.
+
+.. ocv:function:: static Ptr<TrackerSamplerAlgorithm> TrackerSamplerAlgorithm::create( const String& trackerSamplerType )
+
+ :param trackerSamplerType: The trackerSamplerType name
+
+The modes available now:
+
+* ``"CSC"`` -- Current State Center
+
+* ``"CS"`` -- Current State
+
+
+TrackerSamplerAlgorithm::sampling
+---------------------------------
+
+Computes the regions starting from a position in an image. Return true if samples are computed, false otherwise
+
+.. ocv:function:: bool TrackerSamplerAlgorithm::sampling( const Mat& image, Rect boundingBox, std::vector<Mat>& sample )
+
+ :param image: The current frame
+
+ :param boundingBox: The bounding box from which regions can be calculated
+
+ :sample: The computed samples [AAM]_ Fig. 1 variable Sk
+
+TrackerSamplerAlgorithm::getClassName
+-------------------------------------
+
+Get the name of the specific TrackerSamplerAlgorithm
+
+.. ocv:function:: String TrackerSamplerAlgorithm::getClassName() const
+
+Specialized TrackerSamplerAlgorithm
+===================================
+
+In [AAM]_ table I are described the most known sampling strategies. At moment :ocv:class:`TrackerSamplerCSC` and :ocv:class:`TrackerSamplerCS` are implemented.
+
+TrackerSamplerCSC : TrackerSamplerAlgorithm
+-------------------------------------------
+
+TrackerSampler based on CSC (current state centered), used by MIL algorithm TrackerMIL
+
+.. ocv:class:: TrackerSamplerCSC
+
+TrackerSamplerCSC class::
+
+
+ class CV_EXPORTS_W TrackerSamplerCSC
+ {
+ public:
+
+ TrackerSamplerCSC( const TrackerSamplerCSC::Params ¶meters = TrackerSamplerCSC::Params() );
+ void setMode( int samplingMode );
+
+ ~TrackerSamplerCSC();
+ };
+
+
+TrackerSamplerCSC::Params
+-------------------------
+
+.. ocv:struct:: TrackerSamplerCSC::Params
+
+List of TrackerSamplerCSC parameters::
+
+ struct CV_EXPORTS Params
+ {
+ Params();
+ float initInRad; // radius for gathering positive instances during init
+ float trackInPosRad; // radius for gathering positive instances during tracking
+ float searchWinSize; // size of search window
+ int initMaxNegNum; // # negative samples to use during init
+ int trackMaxPosNum; // # positive samples to use during training
+ int trackMaxNegNum; // # negative samples to use during training
+ };
+
+
+TrackerSamplerCSC::TrackerSamplerCSC
+------------------------------------
+
+Constructor
+
+.. ocv:function:: TrackerSamplerCSC::TrackerSamplerCSC( const TrackerSamplerCSC::Params ¶meters = TrackerSamplerCSC::Params() )
+
+ :param parameters: TrackerSamplerCSC parameters :ocv:struct:`TrackerSamplerCSC::Params`
+
+TrackerSamplerCSC::setMode
+--------------------------
+
+Set the sampling mode of TrackerSamplerCSC
+
+.. ocv:function:: void TrackerSamplerCSC::setMode( int samplingMode )
+
+ :param samplingMode: The sampling mode
+
+The modes are:
+
+* ``"MODE_INIT_POS = 1"`` -- for the positive sampling in initialization step
+* ``"MODE_INIT_NEG = 2"`` -- for the negative sampling in initialization step
+* ``"MODE_TRACK_POS = 3"`` -- for the positive sampling in update step
+* ``"MODE_TRACK_NEG = 4"`` -- for the negative sampling in update step
+* ``"MODE_DETECT = 5"`` -- for the sampling in detection step
+
+TrackerSamplerCS : TrackerSamplerAlgorithm
+-------------------------------------------
+
+TrackerSampler based on CS (current state), used by algorithm TrackerBoosting
+
+.. ocv:class:: TrackerSamplerCS
+
+TrackerSamplerCS class::
+
+
+ class CV_EXPORTS_W TrackerSamplerCS
+ {
+ public:
+
+ TrackerSamplerCS( const TrackerSamplerCS::Params ¶meters = TrackerSamplerCS::Params() );
+ void setMode( int samplingMode );
+
+ ~TrackerSamplerCS();
+ };
+
+
+TrackerSamplerCS::Params
+-------------------------
+
+.. ocv:struct:: TrackerSamplerCS::Params
+
+List of TrackerSamplerCS parameters::
+
+ struct CV_EXPORTS Params
+ {
+ Params();
+ float overlap; //overlapping for the search windows
+ float searchFactor; //search region parameter
+ };
+
+
+TrackerSamplerCS::TrackerSamplerCS
+------------------------------------
+
+Constructor
+
+.. ocv:function:: TrackerSamplerCS::TrackerSamplerCS( const TrackerSamplerCS::Params ¶meters = TrackerSamplerCS::Params() )
+
+ :param parameters: TrackerSamplerCS parameters :ocv:struct:`TrackerSamplerCS::Params`
+
+TrackerSamplerCS::setMode
+--------------------------
+
+Set the sampling mode of TrackerSamplerCS
+
+.. ocv:function:: void TrackerSamplerCS::setMode( int samplingMode )
+
+ :param samplingMode: The sampling mode
+
+The modes are:
+
+* ``"MODE_POSITIVE = 1"`` -- for the positive sampling
+* ``"MODE_NEGATIVE = 2"`` -- for the negative sampling
+* ``"MODE_CLASSIFY = 3"`` -- for the sampling in classification step
diff --git a/modules/tracking/doc/misc/Tracker.txt b/modules/tracking/doc/misc/Tracker.txt
new file mode 100644
index 000000000..9bacdfeda
--- /dev/null
+++ b/modules/tracking/doc/misc/Tracker.txt
@@ -0,0 +1,43 @@
+@startuml
+package "Tracker package" #DDDDDD {
+
+
+
+
+class Algorithm {
+}
+class Tracker{
+ Ptr<TrackerFeatureSet> featureSet;
+ Ptr<TrackerSampler> sampler;
+ Ptr<TrackerModel> model;
+ ---
+ +static Ptr<Tracker> create(const string& trackerType);
+ +bool init(const Mat& image, const Rect& boundingBox);
+ +bool update(const Mat& image, Rect& boundingBox);
+}
+class Tracker
+note right: Tracker is the general interface for each specialized trackers
+class TrackerMIL{
+ +Params
+ ---
+ TrackerMIL(TrackerMIL::Params parameters);
+ +bool init(const Mat& image, const Rect& boundingBox);
+ +bool update(const Mat& image, Rect& boundingBox);
+}
+class TrackerBoosting{
+ +Params
+ ---
+ TrackerBoosting(TrackerBoosting::Params parameters);
+ +bool init(const Mat& image, const Rect& boundingBox);
+ +bool update(const Mat& image, Rect& boundingBox);
+}
+Algorithm <|-- Tracker : virtual inheritance
+Tracker <|-- TrackerMIL
+Tracker <|-- TrackerBoosting
+
+note "Single instance of the Tracker" as N1
+TrackerBoosting .. N1
+TrackerMIL .. N1
+}
+
+@enduml
diff --git a/modules/tracking/doc/misc/TrackerFeature.txt b/modules/tracking/doc/misc/TrackerFeature.txt
new file mode 100644
index 000000000..b09818a7b
--- /dev/null
+++ b/modules/tracking/doc/misc/TrackerFeature.txt
@@ -0,0 +1,55 @@
+@startuml
+package "TrackerFeature package" #DDDDDD {
+
+class TrackerFeatureSet{
+ -vector<pair<string, Ptr<TrackerFeature> > > features
+ -vector<Mat> responses
+ ...
+ TrackerFeatureSet();
+ ~TrackerFeatureSet();
+ --
+ +extraction(const std::vector<Mat>& images);
+ +selection();
+ +removeOutliers();
+ +vector<Mat> response getResponses();
+ +vector<pair<string TrackerFeatureType, Ptr<TrackerFeature> > > getTrackerFeatures();
+ +bool addTrackerFeature(string trackerFeatureType);
+ +bool addTrackerFeature(Ptr<TrackerFeature>& feature);
+ -clearResponses();
+}
+
+class TrackerFeature <<virtual>>{
+ static Ptr<TrackerFeature> = create(const string& trackerFeatureType);
+ compute(const std::vector<Mat>& images, Mat& response);
+ selection(Mat& response, int npoints);
+}
+note bottom: Can be specialized as in table II\nA tracker can use more types of features
+
+class TrackerFeatureFeature2D{
+ -vector<Keypoints> keypoints
+ ---
+ TrackerFeatureFeature2D(string detectorType, string descriptorType);
+ ~TrackerFeatureFeature2D();
+ ---
+ compute(const std::vector<Mat>& images, Mat& response);
+ selection( Mat& response, int npoints);
+}
+class TrackerFeatureHOG{
+ TrackerFeatureHOG();
+ ~TrackerFeatureHOG();
+ ---
+ compute(const std::vector<Mat>& images, Mat& response);
+ selection(Mat& response, int npoints);
+}
+
+TrackerFeatureSet *-- TrackerFeature
+TrackerFeature <|-- TrackerFeatureHOG
+TrackerFeature <|-- TrackerFeatureFeature2D
+
+
+note "Per readability and simplicity in this diagram\n there are only two TrackerFeature but you\n can considering the implementation of the other TrackerFeature" as N1
+TrackerFeatureHOG .. N1
+TrackerFeatureFeature2D .. N1
+}
+
+@enduml
diff --git a/modules/tracking/doc/misc/TrackerModel.txt b/modules/tracking/doc/misc/TrackerModel.txt
new file mode 100644
index 000000000..e25281a07
--- /dev/null
+++ b/modules/tracking/doc/misc/TrackerModel.txt
@@ -0,0 +1,62 @@
+@startuml
+package "TrackerModel package" #DDDDDD {
+
+class Typedef << (T,#FF7700) >>{
+ ConfidenceMap
+ Trajectory
+}
+
+class TrackerModel{
+ -vector<ConfidenceMap> confidenceMaps;
+ -Trajectory trajectory;
+ -Ptr<TrackerStateEstimator> stateEstimator;
+ ...
+ TrackerModel();
+ ~TrackerModel();
+
+ +bool setTrackerStateEstimator(Ptr<TrackerStateEstimator> trackerStateEstimator);
+ +Ptr<TrackerStateEstimator> getTrackerStateEstimator();
+
+ +void modelEstimation(const vector<Mat>& responses);
+ +void modelUpdate();
+ +void setLastTargetState(const Ptr<TrackerTargetState> lastTargetState);
+ +void runStateEstimator();
+
+ +const vector<ConfidenceMap>& getConfidenceMaps();
+ +const ConfidenceMap& getLastConfidenceMap();
+}
+class TrackerTargetState <<virtual>>{
+ Point2f targetPosition;
+ ---
+ Point2f getTargetPosition();
+ void setTargetPosition(Point2f position);
+}
+class TrackerTargetState
+note bottom: Each TrackerStateEstimator can create own state
+
+class TrackerStateEstimator <<virtual>>{
+ ~TrackerStateEstimator();
+ static Ptr<TrackerStateEstimator> create(const String& trackeStateEstimatorType);
+ Ptr<TrackerTargetState> estimate(const vector<ConfidenceMap>& confidenceMaps)
+ void update(vector<ConfidenceMap>& confidenceMaps)
+}
+
+class TrackerStateEstimatorSVM{
+ TrackerStateEstimatorSVM()
+ ~TrackerStateEstimatorSVM()
+ Ptr<TrackerTargetState> estimate(const vector<ConfidenceMap>& confidenceMaps)
+ void update(vector<ConfidenceMap>& confidenceMaps)
+}
+class TrackerStateEstimatorMILBoosting{
+ TrackerStateEstimatorMILBoosting()
+ ~TrackerStateEstimatorMILBoosting()
+ Ptr<TrackerTargetState> estimate(const vector<ConfidenceMap>& confidenceMaps)
+ void update(vector<ConfidenceMap>& confidenceMaps)
+}
+
+TrackerModel -> TrackerStateEstimator: create
+TrackerModel *-- TrackerTargetState
+TrackerStateEstimator <|-- TrackerStateEstimatorMILBoosting
+TrackerStateEstimator <|-- TrackerStateEstimatorSVM
+}
+@enduml
diff --git a/modules/tracking/doc/misc/TrackerSampler.txt b/modules/tracking/doc/misc/TrackerSampler.txt
new file mode 100644
index 000000000..61b174ecb
--- /dev/null
+++ b/modules/tracking/doc/misc/TrackerSampler.txt
@@ -0,0 +1,44 @@
+@startuml
+package "TrackerSampler package" #DDDDDD {
+
+class TrackerSampler{
+ -vector<pair<String, Ptr<TrackerSamplerAlgorithm> > > samplers
+ -vector<Mat> samples;
+ ...
+ TrackerSampler();
+ ~TrackerSampler();
+ +sampling(const Mat& image, Rect boundingBox);
+ +const vector<pair<String, Ptr<TrackerSamplerAlgorithm> > >& getSamplers();
+ +const vector<Mat>& getSamples();
+ +bool addTrackerSamplerAlgorithm(String trackerSamplerAlgorithmType);
+ +bool addTrackerSamplerAlgorithm(Ptr<TrackerSamplerAlgorithm>& sampler);
+ ---
+ -void clearSamples();
+}
+
+class TrackerSamplerAlgorithm{
+ ~TrackerSamplerAlgorithm();
+ +static Ptr<TrackerSamplerAlgorithm> create(const String& trackerSamplerType);
+ +bool sampling(const Mat& image, Rect boundingBox, vector<Mat>& sample);
+}
+note bottom: A tracker could sample the target\nor it could sample the target and the background
+
+
+class TrackerSamplerCS{
+ TrackerSamplerCS();
+ ~TrackerSamplerCS();
+ +bool sampling(const Mat& image, Rect boundingBox, vector<Mat>& sample);
+}
+class TrackerSamplerCSC{
+ TrackerSamplerCSC();
+ ~TrackerSamplerCSC();
+ +bool sampling(const Mat& image, Rect boundingBox, vector<Mat>& sample);
+}
+
+
+
+TrackerSampler *-- TrackerSamplerAlgorithm
+TrackerSamplerAlgorithm <|-- TrackerSamplerCS
+TrackerSamplerAlgorithm <|-- TrackerSamplerCSC
+}
+@enduml
diff --git a/modules/tracking/doc/misc/packages.txt b/modules/tracking/doc/misc/packages.txt
new file mode 100644
index 000000000..085b43553
--- /dev/null
+++ b/modules/tracking/doc/misc/packages.txt
@@ -0,0 +1,19 @@
+@startuml
+package "Tracker" #DDDDDD {
+
+}
+package "TrackerFeature" #DDDDDD {
+
+}
+package "TrackerSampler" #DDDDDD {
+
+}
+package "TrackerModel" #DDDDDD {
+
+}
+Tracker -> TrackerModel: create
+Tracker -> TrackerSampler: create
+Tracker -> TrackerFeature: create
+
+
+@enduml
\ No newline at end of file
diff --git a/modules/tracking/doc/pics/Tracker.png b/modules/tracking/doc/pics/Tracker.png
new file mode 100644
index 0000000000000000000000000000000000000000..f5aa2bbd17e29ce882306a142d0a1f73d812cfb9
GIT binary patch
literal 32315
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
LIq_UE-M9Y-y?i2;
literal 0
HcmV?d00001
diff --git a/modules/tracking/doc/pics/TrackerFeature.png b/modules/tracking/doc/pics/TrackerFeature.png
new file mode 100644
index 0000000000000000000000000000000000000000..8533be0c79a9f9ac0d13f76a8ae6edad88526132
GIT binary patch
literal 60096
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
literal 0
HcmV?d00001
diff --git a/modules/tracking/doc/pics/TrackerModel.png b/modules/tracking/doc/pics/TrackerModel.png
new file mode 100644
index 0000000000000000000000000000000000000000..7eb446dde46e252a4bee8a929f8d554bf63c1c01
GIT binary patch
literal 57820
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�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
E0>9#2?*IS*
literal 0
HcmV?d00001
diff --git a/modules/tracking/doc/pics/TrackerSampler.png b/modules/tracking/doc/pics/TrackerSampler.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad00a32f318b4dd6a70d005637c4ccba87961467
GIT binary patch
literal 48429
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
literal 0
HcmV?d00001
diff --git a/modules/tracking/doc/pics/package.png b/modules/tracking/doc/pics/package.png
new file mode 100644
index 0000000000000000000000000000000000000000..adff6a8b70017759aeb3344a10d2112d7008ccbc
GIT binary patch
literal 8746
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
G`Tif%e0NF!
literal 0
HcmV?d00001
diff --git a/modules/tracking/doc/tracker_algorithms.rst b/modules/tracking/doc/tracker_algorithms.rst
new file mode 100644
index 000000000..519fb4219
--- /dev/null
+++ b/modules/tracking/doc/tracker_algorithms.rst
@@ -0,0 +1,121 @@
+Tracker Algorithms
+==================
+
+.. highlight:: cpp
+
+Two algorithms will be implemented soon, the first is MIL (Multiple Instance Learning) [MIL]_ and second is Online Boosting [OLB]_.
+
+.. [MIL] B Babenko, M-H Yang, and S Belongie, Visual Tracking with Online Multiple Instance Learning, In CVPR, 2009
+
+.. [OLB] H Grabner, M Grabner, and H Bischof, Real-time tracking via on-line boosting, In Proc. BMVC, volume 1, pages 47– 56, 2006
+
+TrackerBoosting
+---------------
+
+This is a real-time object tracking based on a novel on-line version of the AdaBoost algorithm.
+The classifier uses the surrounding background as negative examples in update step to avoid the drifting problem.
+
+.. ocv:class:: TrackerBoosting
+
+Implementation of TrackerBoosting from :ocv:class:`Tracker`::
+
+ class CV_EXPORTS_W TrackerBoosting : public Tracker
+ {
+ public:
+
+ TrackerBoosting( const TrackerBoosting::Params ¶meters = TrackerBoosting::Params() );
+
+ virtual ~TrackerBoosting();
+
+ void read( const FileNode& fn );
+ void write( FileStorage& fs ) const;
+
+
+ };
+
+TrackerMIL
+----------
+
+The MIL algorithm trains a classifier in an online manner to separate the object from the background. Multiple Instance Learning avoids the drift problem for a robust tracking.
+
+Original code can be found here http://vision.ucsd.edu/~bbabenko/project_miltrack.shtml
+
+.. ocv:class:: TrackerMIL
+
+Implementation of TrackerMIL from :ocv:class:`Tracker`::
+
+ class CV_EXPORTS_W TrackerMIL : public Tracker
+ {
+ public:
+
+ TrackerMIL( const TrackerMIL::Params ¶meters = TrackerMIL::Params() );
+
+ virtual ~TrackerMIL();
+
+ void read( const FileNode& fn );
+ void write( FileStorage& fs ) const;
+
+ };
+
+TrackerMIL::Params
+------------------
+
+.. ocv:struct:: TrackerMIL::Params
+
+List of MIL parameters::
+
+ 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;
+ };
+
+TrackerMIL::TrackerMIL
+----------------------
+
+Constructor
+
+.. ocv:function:: bool TrackerMIL::TrackerMIL( const TrackerMIL::Params ¶meters = TrackerMIL::Params() )
+
+ :param parameters: MIL parameters :ocv:struct:`TrackerMIL::Params`
+
+
+TrackerBoosting::Params
+------------------
+
+.. ocv:struct:: TrackerBoosting::Params
+
+List of BOOSTING parameters::
+
+ struct CV_EXPORTS Params
+ {
+ Params();
+ int numClassifiers; //the number of classifiers to use in a OnlineBoosting algorithm
+ float samplerOverlap; //search region parameters to use in a OnlineBoosting algorithm
+ float samplerSearchFactor; // search region parameters to use in a OnlineBoosting algorithm
+ int iterationInit; //the initial iterations
+ int featureSetNumFeatures; // #features
+
+ void read( const FileNode& fn );
+ void write( FileStorage& fs ) const;
+ };
+
+TrackerBoosting::TrackerBoosting
+----------------------
+
+Constructor
+
+.. ocv:function:: bool TrackerBoosting::TrackerBoosting( const TrackerBoosting::Params ¶meters = TrackerBoosting::Params() )
+
+ :param parameters: BOOSTING parameters :ocv:struct:`TrackerBoosting::Params`
diff --git a/modules/tracking/doc/tracking.rst b/modules/tracking/doc/tracking.rst
new file mode 100644
index 000000000..8ad9fd56a
--- /dev/null
+++ b/modules/tracking/doc/tracking.rst
@@ -0,0 +1,86 @@
+Tracking API
+============
+
+.. highlight:: cpp
+
+
+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 [AAM]_ and [AMVOT]_.
+
+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 [OOT]_.
+
+UML design:
+-----------
+
+**General diagram**
+
+.. image:: pics/package.png
+ :width: 50%
+ :alt: General diagram
+ :align: center
+
+**Tracker diagram**
+
+.. image:: pics/Tracker.png
+ :width: 80%
+ :alt: Tracker diagram
+ :align: center
+
+**TrackerSampler diagram**
+
+.. image:: pics/TrackerSampler.png
+ :width: 100%
+ :alt: TrackerSampler diagram
+ :align: center
+
+**TrackerFeatureSet diagram**
+
+.. image:: pics/TrackerFeature.png
+ :width: 100%
+ :alt: TrackerFeatureSet diagram
+ :align: center
+
+**TrackerModel diagram**
+
+.. image:: pics/TrackerModel.png
+ :width: 100%
+ :alt: TrackerModel diagram
+ :align: center
+
+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 files under modules/tracking/misc/
+
+The following reference was used in the API
+
+.. [AAM] S Salti, A Cavallaro, L Di Stefano, Adaptive Appearance Modeling for Video Tracking: Survey and Evaluation, IEEE Transactions on Image Processing, Vol. 21, Issue 10, October 2012, pp. 4334-4348
+
+.. [AMVOT] X Li, W Hu, C Shen, Z Zhang, A Dick, A van den Hengel, A Survey of Appearance Models in Visual Object Tracking, ACM Transactions on Intelligent Systems and Technology (TIST), 2013
+
+.. [OOT] Yi Wu and Jongwoo Lim and Ming-Hsuan Yang, Online Object Tracking: A Benchmark, The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2013
+
+
+Tracker classes:
+----------------
+
+.. toctree::
+ :maxdepth: 2
+
+ tracker_algorithms
+ common_interfaces_tracker
+ common_interfaces_tracker_sampler
+ common_interfaces_tracker_feature_set
+ common_interfaces_tracker_model
diff --git a/modules/tracking/include/opencv2/tracking.hpp b/modules/tracking/include/opencv2/tracking.hpp
new file mode 100644
index 000000000..55fb05d40
--- /dev/null
+++ b/modules/tracking/include/opencv2/tracking.hpp
@@ -0,0 +1,52 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_TRACKING_HPP__
+#define __OPENCV_TRACKING_HPP__
+
+#include "opencv2/tracking/tracker.hpp"
+
+namespace cv
+{
+CV_EXPORTS bool initModule_tracking(void);
+}
+
+#endif //__OPENCV_TRACKING_HPP__
diff --git a/modules/tracking/include/opencv2/tracking/feature.hpp b/modules/tracking/include/opencv2/tracking/feature.hpp
new file mode 100644
index 000000000..34c0f15af
--- /dev/null
+++ b/modules/tracking/include/opencv2/tracking/feature.hpp
@@ -0,0 +1,410 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_FEATURE_HPP__
+#define __OPENCV_FEATURE_HPP__
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+#include <string>
+#include <time.h>
+
+/*
+ * TODO This implementation is based on apps/traincascade/
+ * TODO Changed CvHaarEvaluator based on ADABOOSTING implementation (Grabner et al.)
+ */
+
+namespace cv
+{
+
+#define FEATURES "features"
+
+#define CC_FEATURES FEATURES
+#define CC_FEATURE_PARAMS "featureParams"
+#define CC_MAX_CAT_COUNT "maxCatCount"
+#define CC_FEATURE_SIZE "featSize"
+#define CC_NUM_FEATURES "numFeat"
+#define CC_ISINTEGRAL "isIntegral"
+#define CC_RECTS "rects"
+#define CC_TILTED "tilted"
+#define CC_RECT "rect"
+
+#define LBPF_NAME "lbpFeatureParams"
+#define HOGF_NAME "HOGFeatureParams"
+#define HFP_NAME "haarFeatureParams"
+
+#define CV_HAAR_FEATURE_MAX 3
+#define N_BINS 9
+#define N_CELLS 4
+
+#define CV_SUM_OFFSETS( p0, p1, p2, p3, rect, step ) \
+ /* (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 ) \
+ /* (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);
+
+float calcNormFactor( const Mat& sum, const Mat& sqSum );
+
+template<class Feature>
+void _writeFeatures( const std::vector<Feature> features, FileStorage &fs, const Mat& featureMap )
+{
+ fs << FEATURES << "[";
+ const Mat_<int>& featureMap_ = (const Mat_<int>&) featureMap;
+ for ( int fi = 0; fi < featureMap.cols; fi++ )
+ if( featureMap_( 0, fi ) >= 0 )
+ {
+ fs << "{";
+ features[fi].write( fs );
+ fs << "}";
+ }
+ fs << "]";
+}
+
+class CvParams
+{
+ public:
+ CvParams();
+ virtual ~CvParams()
+ {
+ }
+ // from|to file
+ virtual void write( FileStorage &fs ) const = 0;
+ virtual bool read( const FileNode &node ) = 0;
+ // from|to screen
+ virtual void printDefaults() const;
+ virtual void printAttrs() const;
+ virtual bool scanAttr( const std::string prmName, const std::string val );
+ std::string name;
+};
+
+class CvFeatureParams : public CvParams
+{
+ public:
+ enum
+ {
+ HAAR = 0,
+ LBP = 1,
+ HOG = 2
+ };
+ CvFeatureParams();
+ virtual void init( const CvFeatureParams& fp );
+ virtual void write( FileStorage &fs ) const;
+ virtual bool read( const FileNode &node );
+ static Ptr<CvFeatureParams> create( int featureType );
+ int maxCatCount; // 0 in case of numerical features
+ int featSize; // 1 in case of simple features (HAAR, LBP) and N_BINS(9)*N_CELLS(4) in case of Dalal's HOG features
+ int numFeatures;
+};
+
+class CvFeatureEvaluator
+{
+ public:
+ virtual ~CvFeatureEvaluator()
+ {
+ }
+ virtual void init( const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize );
+ virtual void setImage( const Mat& img, uchar clsLabel, int idx );
+ virtual void writeFeatures( FileStorage &fs, const Mat& featureMap ) const = 0;
+ virtual float operator()( int featureIdx, int sampleIdx ) = 0;
+ static Ptr<CvFeatureEvaluator> create( int type );
+
+ int getNumFeatures() const
+ {
+ return numFeatures;
+ }
+ int getMaxCatCount() const
+ {
+ return featureParams->maxCatCount;
+ }
+ int getFeatureSize() const
+ {
+ return featureParams->featSize;
+ }
+ const Mat& getCls() const
+ {
+ return cls;
+ }
+ float getCls( int si ) const
+ {
+ return cls.at<float>( si, 0 );
+ }
+ protected:
+ virtual void generateFeatures() = 0;
+
+ int npos, nneg;
+ int numFeatures;
+ Size winSize;
+ CvFeatureParams *featureParams;
+ Mat cls;
+};
+
+class CvHaarFeatureParams : public CvFeatureParams
+{
+ public:
+
+ CvHaarFeatureParams();
+
+ virtual void init( const CvFeatureParams& fp );
+ virtual void write( FileStorage &fs ) const;
+ virtual bool read( const FileNode &node );
+
+ virtual void printDefaults() const;
+ virtual void printAttrs() const;
+ virtual bool scanAttr( const std::string prm, const std::string val );
+
+ bool isIntegral;
+};
+
+class CvHaarEvaluator : public CvFeatureEvaluator
+{
+ public:
+
+ class FeatureHaar
+ {
+
+ public:
+
+ FeatureHaar( Size patchSize );
+ bool eval( const Mat& image, Rect ROI, float* result ) const;
+ int getNumAreas();
+ const std::vector<float>& getWeights() const;
+ const std::vector<Rect>& getAreas() const;
+ void write( FileStorage ) const
+ {
+ }
+ ;
+ float getInitMean() const;
+ float getInitSigma() const;
+
+ private:
+ int m_type;
+ int m_numAreas;
+ std::vector<float> m_weights;
+ float m_initMean;
+ float m_initSigma;
+ void generateRandomFeature( Size imageSize );
+ float getSum( const Mat& image, Rect imgROI ) const;
+ std::vector<Rect> m_areas; // areas within the patch over which to compute the feature
+ cv::Size m_initSize; // size of the patch used during training
+ cv::Size m_curSize; // size of the patches currently under investigation
+ float m_scaleFactorHeight; // scaling factor in vertical direction
+ float m_scaleFactorWidth; // scaling factor in horizontal direction
+ std::vector<Rect> m_scaleAreas; // areas after scaling
+ std::vector<float> m_scaleWeights; // weights after scaling
+
+ };
+
+ virtual void init( const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize );
+ virtual void setImage( const Mat& img, uchar clsLabel = 0, int idx = 1 );
+ virtual float operator()( int featureIdx, int sampleIdx );
+ virtual void writeFeatures( FileStorage &fs, const Mat& featureMap ) const;
+ void writeFeature( FileStorage &fs ) const; // for old file format
+ const std::vector<CvHaarEvaluator::FeatureHaar>& getFeatures() const;
+ inline CvHaarEvaluator::FeatureHaar& getFeatures( int idx )
+ {
+ return features[idx];
+ }
+ void setWinSize( Size patchSize );
+ Size setWinSize() const;
+ virtual void generateFeatures();
+
+ /**
+ * TODO new method
+ * \brief Overload the original generateFeatures in order to limit the number of the features
+ * @param numFeatures Number of the features
+ */
+
+ virtual void generateFeatures( int numFeatures );
+
+ protected:
+ bool isIntegral;
+
+ /* TODO Added from MIL implementation */
+ Mat _ii_img;
+ void compute_integral( const cv::Mat & img, std::vector<cv::Mat_<float> > & ii_imgs )
+ {
+ Mat ii_img;
+ integral( img, ii_img, CV_32F );
+ split( ii_img, ii_imgs );
+ }
+
+ std::vector<FeatureHaar> features;
+ Mat sum; /* sum images (each row represents image) */
+};
+
+struct CvHOGFeatureParams : public CvFeatureParams
+{
+ CvHOGFeatureParams();
+};
+
+class CvHOGEvaluator : public CvFeatureEvaluator
+{
+ public:
+ virtual ~CvHOGEvaluator()
+ {
+ }
+ virtual void init( const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize );
+ virtual void setImage( const Mat& img, uchar clsLabel, int idx );
+ virtual float operator()( int varIdx, int sampleIdx );
+ virtual void writeFeatures( FileStorage &fs, const Mat& featureMap ) const;
+ protected:
+ virtual void generateFeatures();
+ virtual void integralHistogram( const Mat &img, std::vector<Mat> &histogram, Mat &norm, int nbins ) const;
+ class Feature
+ {
+ public:
+ Feature();
+ Feature( int offset, int x, int y, int cellW, int cellH );
+ float calc( const std::vector<Mat> &_hists, const Mat &_normSum, size_t y, int featComponent ) const;
+ void write( FileStorage &fs ) const;
+ void write( FileStorage &fs, int varIdx ) const;
+
+ Rect rect[N_CELLS]; //cells
+
+ struct
+ {
+ int p0, p1, p2, p3;
+ } fastRect[N_CELLS];
+ };
+ std::vector<Feature> features;
+
+ Mat normSum; //for nomalization calculation (L1 or L2)
+ std::vector<Mat> hist;
+};
+
+inline float CvHOGEvaluator::operator()( int varIdx, int sampleIdx )
+{
+ int featureIdx = varIdx / ( N_BINS * N_CELLS );
+ int componentIdx = varIdx % ( N_BINS * N_CELLS );
+ //return features[featureIdx].calc( hist, sampleIdx, componentIdx);
+ return features[featureIdx].calc( hist, normSum, sampleIdx, componentIdx );
+}
+
+inline float CvHOGEvaluator::Feature::calc( const std::vector<Mat>& _hists, const Mat& _normSum, size_t y, int featComponent ) const
+{
+ float normFactor;
+ float res;
+
+ int binIdx = featComponent % N_BINS;
+ int cellIdx = featComponent / N_BINS;
+
+ const float *phist = _hists[binIdx].ptr<float>( (int) y );
+ res = phist[fastRect[cellIdx].p0] - phist[fastRect[cellIdx].p1] - phist[fastRect[cellIdx].p2] + phist[fastRect[cellIdx].p3];
+
+ const float *pnormSum = _normSum.ptr<float>( (int) y );
+ normFactor = (float) ( pnormSum[fastRect[0].p0] - pnormSum[fastRect[1].p1] - pnormSum[fastRect[2].p2] + pnormSum[fastRect[3].p3] );
+ res = ( res > 0.001f ) ? ( res / ( normFactor + 0.001f ) ) : 0.f; //for cutting negative values, which apper due to floating precision
+
+ return res;
+}
+
+struct CvLBPFeatureParams : CvFeatureParams
+{
+ CvLBPFeatureParams();
+
+};
+
+class CvLBPEvaluator : public CvFeatureEvaluator
+{
+ public:
+ virtual ~CvLBPEvaluator()
+ {
+ }
+ virtual void init( const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize );
+ virtual void setImage( const Mat& img, uchar clsLabel, int idx );
+ virtual float operator()( int featureIdx, int sampleIdx )
+ {
+ return (float) features[featureIdx].calc( sum, sampleIdx );
+ }
+ virtual void writeFeatures( FileStorage &fs, const Mat& featureMap ) const;
+ protected:
+ virtual void generateFeatures();
+
+ class Feature
+ {
+ public:
+ Feature();
+ Feature( int offset, int x, int y, int _block_w, int _block_h );
+ uchar calc( const Mat& _sum, size_t y ) const;
+ void write( FileStorage &fs ) const;
+
+ Rect rect;
+ int p[16];
+ };
+ std::vector<Feature> features;
+
+ Mat sum;
+};
+
+inline uchar CvLBPEvaluator::Feature::calc( const Mat &_sum, size_t y ) const
+{
+ const int* psum = _sum.ptr<int>( (int) y );
+ int cval = psum[p[5]] - psum[p[6]] - psum[p[9]] + psum[p[10]];
+
+ return (uchar) ( ( psum[p[0]] - psum[p[1]] - psum[p[4]] + psum[p[5]] >= cval ? 128 : 0 ) | // 0
+ ( psum[p[1]] - psum[p[2]] - psum[p[5]] + psum[p[6]] >= cval ? 64 : 0 ) | // 1
+ ( psum[p[2]] - psum[p[3]] - psum[p[6]] + psum[p[7]] >= cval ? 32 : 0 ) | // 2
+ ( psum[p[6]] - psum[p[7]] - psum[p[10]] + psum[p[11]] >= cval ? 16 : 0 ) | // 5
+ ( psum[p[10]] - psum[p[11]] - psum[p[14]] + psum[p[15]] >= cval ? 8 : 0 ) | // 8
+ ( psum[p[9]] - psum[p[10]] - psum[p[13]] + psum[p[14]] >= cval ? 4 : 0 ) | // 7
+ ( psum[p[8]] - psum[p[9]] - psum[p[12]] + psum[p[13]] >= cval ? 2 : 0 ) | // 6
+ ( psum[p[4]] - psum[p[5]] - psum[p[8]] + psum[p[9]] >= cval ? 1 : 0 ) ); // 3
+}
+
+} /* namespace cv */
+
+#endif
diff --git a/modules/tracking/include/opencv2/tracking/onlineBoosting.hpp b/modules/tracking/include/opencv2/tracking/onlineBoosting.hpp
new file mode 100644
index 000000000..d0eb3a10b
--- /dev/null
+++ b/modules/tracking/include/opencv2/tracking/onlineBoosting.hpp
@@ -0,0 +1,282 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_ONLINEBOOSTING_HPP__
+#define __OPENCV_ONLINEBOOSTING_HPP__
+
+#include "opencv2/core.hpp"
+
+namespace cv
+{
+//TODO based on the original implementation
+//http://vision.ucsd.edu/~bbabenko/project_miltrack.shtml
+
+class BaseClassifier;
+class WeakClassifierHaarFeature;
+class EstimatedGaussDistribution;
+class ClassifierThreshold;
+class Detector;
+
+class StrongClassifierDirectSelection
+{
+ public:
+
+ StrongClassifierDirectSelection( int numBaseClf, int numWeakClf, Size patchSz, const Rect& sampleROI, bool useFeatureEx = false, int iterationInit =
+ 0 );
+ virtual ~StrongClassifierDirectSelection();
+
+ void initBaseClassifier();
+
+ bool update( const Mat& image, int target, float importance = 1.0 );
+ float eval( const Mat& response );
+ std::vector<int> getSelectedWeakClassifier();
+ float classifySmooth( const std::vector<Mat>& images, const Rect& sampleROI, int& idx );
+ int getNumBaseClassifier();
+ Size getPatchSize() const;
+ Rect getROI() const;
+ bool getUseFeatureExchange() const;
+ int getReplacedClassifier() const;
+
+ void replaceWeakClassifier( int idx );
+ int getSwappedClassifier() const;
+ private:
+
+ //StrongClassifier
+ int numBaseClassifier;
+ int numAllWeakClassifier;
+ int numWeakClassifier;
+ int iterInit;
+ BaseClassifier** baseClassifier;
+ std::vector<float> alpha;
+ cv::Size patchSize;
+
+ bool useFeatureExchange;
+
+ //StrongClassifierDirectSelection
+ std::vector<bool> m_errorMask;
+ std::vector<float> m_errors;
+ std::vector<float> m_sumErrors;
+
+ Detector* detector;
+ Rect ROI;
+
+ int replacedClassifier;
+ int swappedClassifier;
+};
+
+class BaseClassifier
+{
+ public:
+
+ BaseClassifier( int numWeakClassifier, int iterationInit );
+ BaseClassifier( int numWeakClassifier, int iterationInit, WeakClassifierHaarFeature** weakCls );
+
+ WeakClassifierHaarFeature** getReferenceWeakClassifier()
+ {
+ return weakClassifier;
+ }
+ ;
+ void trainClassifier( const Mat& image, int target, float importance, std::vector<bool>& errorMask );
+ int selectBestClassifier( std::vector<bool>& errorMask, float importance, std::vector<float> & errors );
+ int computeReplaceWeakestClassifier( const std::vector<float> & errors );
+ void replaceClassifierStatistic( int sourceIndex, int targetIndex );
+ int getIdxOfNewWeakClassifier()
+ {
+ return m_idxOfNewWeakClassifier;
+ }
+ ;
+ int eval( const Mat& image );
+ virtual ~BaseClassifier();
+ float getError( int curWeakClassifier );
+ void getErrors( float* errors );
+ int getSelectedClassifier() const;
+ void replaceWeakClassifier( int index );
+
+ protected:
+
+ void generateRandomClassifier();
+ WeakClassifierHaarFeature** weakClassifier;
+ bool m_referenceWeakClassifier;
+ int m_numWeakClassifier;
+ int m_selectedClassifier;
+ int m_idxOfNewWeakClassifier;
+ std::vector<float> m_wCorrect;
+ std::vector<float> m_wWrong;
+ int m_iterationInit;
+
+};
+
+class EstimatedGaussDistribution
+{
+ public:
+
+ EstimatedGaussDistribution();
+ EstimatedGaussDistribution( float P_mean, float R_mean, float P_sigma, float R_sigma );
+ virtual ~EstimatedGaussDistribution();
+ void update( float value ); //, float timeConstant = -1.0);
+ float getMean();
+ float getSigma();
+ void setValues( float mean, float sigma );
+
+ private:
+
+ float m_mean;
+ float m_sigma;
+ float m_P_mean;
+ float m_P_sigma;
+ float m_R_mean;
+ float m_R_sigma;
+};
+
+class WeakClassifierHaarFeature
+{
+
+ public:
+
+ WeakClassifierHaarFeature();
+ virtual ~WeakClassifierHaarFeature();
+
+ bool update( float value, int target );
+ int eval( float value );
+
+ private:
+
+ float sigma;
+ float mean;
+ ClassifierThreshold* m_classifier;
+
+ void getInitialDistribution( EstimatedGaussDistribution *distribution );
+ void generateRandomClassifier( EstimatedGaussDistribution* m_posSamples, EstimatedGaussDistribution* m_negSamples );
+
+};
+
+class Detector
+{
+ public:
+
+ Detector( StrongClassifierDirectSelection* classifier );
+ virtual
+ ~Detector( void );
+
+ void
+ classifySmooth( const std::vector<Mat>& image, float minMargin = 0 );
+
+ int
+ getNumDetections();
+ float
+ getConfidence( int patchIdx );
+ float
+ getConfidenceOfDetection( int detectionIdx );
+
+ float getConfidenceOfBestDetection()
+ {
+ return m_maxConfidence;
+ }
+ ;
+ int
+ getPatchIdxOfBestDetection();
+
+ int
+ getPatchIdxOfDetection( int detectionIdx );
+
+ const std::vector<int> &
+ getIdxDetections() const
+ {
+ return m_idxDetections;
+ }
+ ;
+ const std::vector<float> &
+ getConfidences() const
+ {
+ return m_confidences;
+ }
+ ;
+
+ const cv::Mat &
+ getConfImageDisplay() const
+ {
+ return m_confImageDisplay;
+ }
+
+ private:
+
+ void
+ prepareConfidencesMemory( int numPatches );
+ void
+ prepareDetectionsMemory( int numDetections );
+
+ StrongClassifierDirectSelection* m_classifier;
+ std::vector<float> m_confidences;
+ int m_sizeConfidences;
+ int m_numDetections;
+ std::vector<int> m_idxDetections;
+ int m_sizeDetections;
+ int m_idxBestDetection;
+ float m_maxConfidence;
+ cv::Mat_<float> m_confMatrix;
+ cv::Mat_<float> m_confMatrixSmooth;
+ cv::Mat_<unsigned char> m_confImageDisplay;
+};
+
+class ClassifierThreshold
+{
+ public:
+
+ ClassifierThreshold( EstimatedGaussDistribution* posSamples, EstimatedGaussDistribution* negSamples );
+ virtual ~ClassifierThreshold();
+
+ void update( float value, int target );
+ int eval( float value );
+
+ void* getDistribution( int target );
+
+ private:
+
+ EstimatedGaussDistribution* m_posSamples;
+ EstimatedGaussDistribution* m_negSamples;
+
+ float m_threshold;
+ int m_parity;
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/modules/tracking/include/opencv2/tracking/onlineMIL.hpp b/modules/tracking/include/opencv2/tracking/onlineMIL.hpp
new file mode 100644
index 000000000..2bb006334
--- /dev/null
+++ b/modules/tracking/include/opencv2/tracking/onlineMIL.hpp
@@ -0,0 +1,114 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_ONLINEMIL_HPP__
+#define __OPENCV_ONLINEMIL_HPP__
+
+#include "opencv2/core.hpp"
+#include <limits>
+
+namespace cv
+{
+//TODO based on the original implementation
+//http://vision.ucsd.edu/~bbabenko/project_miltrack.shtml
+
+#define sign(s) ((s > 0 ) ? 1 : ((s<0) ? -1 : 0))
+
+class ClfOnlineStump;
+
+class ClfMilBoost
+{
+ public:
+ struct CV_EXPORTS Params
+ {
+ Params();
+ int _numSel;
+ int _numFeat;
+ float _lRate;
+ };
+
+ ClfMilBoost();
+ ~ClfMilBoost();
+ void init( const ClfMilBoost::Params ¶meters = ClfMilBoost::Params() );
+ void update( const Mat& posx, const Mat& negx );
+ std::vector<float> classify( const Mat& x, bool logR = true );
+
+ inline float sigmoid( float x )
+ {
+ return 1.0f / ( 1.0f + exp( -x ) );
+ }
+
+ private:
+ uint _numsamples;
+ ClfMilBoost::Params _myParams;
+ std::vector<int> _selectors;
+ std::vector<ClfOnlineStump*> _weakclf;
+ uint _counter;
+
+};
+
+class ClfOnlineStump
+{
+ public:
+ float _mu0, _mu1, _sig0, _sig1;
+ float _q;
+ int _s;
+ float _log_n1, _log_n0;
+ float _e1, _e0;
+ float _lRate;
+
+ ClfOnlineStump();
+ ClfOnlineStump( int ind );
+ void init();
+ void update( const Mat& posx, const Mat& negx, const cv::Mat_<float> & posw = cv::Mat_<float>(), const cv::Mat_<float> & negw = cv::Mat_<float>() );
+ bool classify( const Mat& x, int i );
+ float classifyF( const Mat& x, int i );
+ std::vector<float> classifySetF( const Mat& x );
+
+ private:
+ bool _trained;
+ int _ind;
+
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/modules/tracking/include/opencv2/tracking/tracker.hpp b/modules/tracking/include/opencv2/tracking/tracker.hpp
new file mode 100644
index 000000000..bea3e8558
--- /dev/null
+++ b/modules/tracking/include/opencv2/tracking/tracker.hpp
@@ -0,0 +1,1021 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_TRACKER_HPP__
+#define __OPENCV_TRACKER_HPP__
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc/types_c.h"
+#include "feature.hpp"
+#include "onlineMIL.hpp"
+#include "onlineBoosting.hpp"
+#include <iostream>
+
+/*
+ * Partially based on:
+ * ====================================================================================================================
+ * - [AAM] S. Salti, A. Cavallaro, L. Di Stefano, Adaptive Appearance Modeling for Video Tracking: Survey and Evaluation
+ * - [AMVOT] X. Li, W. Hu, C. Shen, Z. Zhang, A. Dick, A. van den Hengel, A Survey of Appearance Models in Visual Object Tracking
+ *
+ * This Tracking API has been designed with PlantUML. If you modify this API please change UML files under modules/tracking/misc/
+ *
+ */
+
+namespace cv
+{
+
+/************************************ TrackerFeature Base Classes ************************************/
+
+/**
+ * \brief Abstract base class for TrackerFeature that represents the feature.
+ */
+class CV_EXPORTS_W TrackerFeature
+{
+ public:
+ virtual ~TrackerFeature();
+
+ /**
+ * \brief Compute the features in the images collection
+ * \param images The images.
+ * \param response Computed features.
+ */
+ void compute( const std::vector<Mat>& images, Mat& response );
+
+ /**
+ * \brief Create TrackerFeature by tracker feature type.
+ */
+ static Ptr<TrackerFeature> create( const String& trackerFeatureType );
+
+ /**
+ * \brief Identify most effective features
+ * \param response Collection of response for the specific TrackerFeature
+ * \param npoints Max number of features
+ */
+ virtual void selection( Mat& response, int npoints ) = 0;
+
+ /**
+ * \brief Get the name of the specific tracker feature
+ * \return The name of the tracker feature
+ */
+ String getClassName() const;
+
+ protected:
+
+ virtual bool computeImpl( const std::vector<Mat>& images, Mat& response ) = 0;
+
+ String className;
+};
+
+/**
+ * \brief Class that manages the extraction and selection of features
+ * [AAM] Feature Extraction and Feature Set Refinement (Feature Processing and Feature Selection). See table I and section III C
+ * [AMVOT] Appearance modelling -> Visual representation (Table II, section 3.1 - 3.2)
+ */
+class CV_EXPORTS_W TrackerFeatureSet
+{
+ public:
+
+ TrackerFeatureSet();
+
+ ~TrackerFeatureSet();
+
+ /**
+ * \brief Extract features from the images collection
+ * \param images The images
+ */
+ void extraction( const std::vector<Mat>& images );
+
+ /**
+ * \brief Identify most effective features for all feature types
+ */
+ void selection();
+
+ /**
+ * \brief Remove outliers for all feature types
+ */
+ void removeOutliers();
+
+ /**
+ * \brief Add TrackerFeature in the collection from tracker feature type
+ * \param trackerFeatureType the tracker feature type FEATURE2D.DETECTOR.DESCRIPTOR - HOG - HAAR - LBP
+ * \return true if feature is added, false otherwise
+ */
+ bool addTrackerFeature( String trackerFeatureType );
+
+ /**
+ * \brief Add TrackerFeature in collection directly
+ * \param feature The TrackerFeature
+ * \return true if feature is added, false otherwise
+ */
+ bool addTrackerFeature( Ptr<TrackerFeature>& feature );
+
+ /**
+ * \brief Get the TrackerFeature collection
+ * \return The TrackerFeature collection
+ */
+ const std::vector<std::pair<String, Ptr<TrackerFeature> > >& getTrackerFeature() const;
+
+ /**
+ * \brief Get the responses
+ * \return the responses
+ */
+ const std::vector<Mat>& getResponses() const;
+
+ private:
+
+ void clearResponses();
+ bool blockAddTrackerFeature;
+
+ std::vector<std::pair<String, Ptr<TrackerFeature> > > features; //list of features
+ std::vector<Mat> responses; //list of response after compute
+
+};
+
+/************************************ TrackerSampler Base Classes ************************************/
+
+/**
+ * \brief Abstract base class for TrackerSamplerAlgorithm that represents the algorithm for the specific sampler.
+ */
+class CV_EXPORTS_W TrackerSamplerAlgorithm
+{
+ public:
+ /**
+ * \brief Destructor
+ */
+ virtual ~TrackerSamplerAlgorithm();
+
+ /**
+ * \brief Create TrackerSamplerAlgorithm by tracker sampler type.
+ */
+ static Ptr<TrackerSamplerAlgorithm> create( const String& trackerSamplerType );
+
+ /**
+ * \brief Computes the regions starting from a position in an image
+ * \param image The image
+ * \param boundingBox The bounding box from which regions can be calculated
+ * \param sample The computed samples [AAM] Fig. 1 variable Sk
+ * \return true if samples are computed, false otherwise
+ */
+ bool sampling( const Mat& image, Rect boundingBox, std::vector<Mat>& sample );
+
+ /**
+ * \brief Get the name of the specific sampler algorithm
+ * \return The name of the tracker sampler algorithm
+ */
+ String getClassName() const;
+
+ protected:
+ String className;
+
+ virtual bool samplingImpl( const Mat& image, Rect boundingBox, std::vector<Mat>& sample ) = 0;
+};
+
+/**
+ * \brief 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
+ */
+class CV_EXPORTS_W TrackerSampler
+{
+ public:
+
+ /**
+ * \brief Constructor
+ */
+ TrackerSampler();
+
+ /**
+ * \brief Destructor
+ */
+ ~TrackerSampler();
+
+ /**
+ * \brief Computes the regions starting from a position in an image
+ * \param image The image
+ * \param boundingBox The bounding box from which regions can be calculated
+ */
+ void sampling( const Mat& image, Rect boundingBox );
+
+ /**
+ * Get the all samplers
+ * \return The samplers
+ */
+ const std::vector<std::pair<String, Ptr<TrackerSamplerAlgorithm> > >& getSamplers() const;
+
+ /**
+ * Get the samples from all TrackerSamplerAlgorithm
+ * \return The samples [AAM] Fig. 1 variable Sk
+ */
+ const std::vector<Mat>& getSamples() const;
+
+ /**
+ * \brief Add TrackerSamplerAlgorithm in the collection from tracker sampler type
+ * \param trackerSamplerAlgorithmType the tracker sampler type CSC - CS
+ * \return true if sampler is added, false otherwise
+ */
+ bool addTrackerSamplerAlgorithm( String trackerSamplerAlgorithmType );
+
+ /**
+ * \brief Add TrackerSamplerAlgorithm in collection directly
+ * \param sampler The TrackerSamplerAlgorithm
+ * \return true if sampler is added, false otherwise
+ */
+ bool addTrackerSamplerAlgorithm( Ptr<TrackerSamplerAlgorithm>& sampler );
+
+ private:
+ std::vector<std::pair<String, Ptr<TrackerSamplerAlgorithm> > > samplers;
+ std::vector<Mat> samples;
+ bool blockAddTrackerSampler;
+
+ void clearSamples();
+};
+
+/************************************ TrackerModel Base Classes ************************************/
+
+/**
+ * \brief Abstract base class for TrackerTargetState that represents a possible state of the target
+ * [AAM] x̄_i all the states candidates
+ * Inherits this with your Target state
+ */
+class CV_EXPORTS_W TrackerTargetState
+{
+ public:
+ virtual ~TrackerTargetState()
+ {
+ }
+ ;
+ /**
+ * \brief Get the position
+ * \return The position
+ */
+ Point2f getTargetPosition() const;
+
+ /**
+ * \brief Set the position
+ * \param position The position
+ */
+ void setTargetPosition( const Point2f& position );
+ /**
+ * \brief Get the width of the target
+ * \return The width of the target
+ */
+ int getTargetWidth() const;
+
+ /**
+ * \brief Set the width of the target
+ * \param width The width of the target
+ */
+ void setTargetWidth( int width );
+ /**
+ * \brief Get the height of the target
+ * \return The height of the target
+ */
+ int getTargetHeight() const;
+
+ /**
+ * \brief Set the height of the target
+ * \param height The height of the target
+ */
+ void setTargetHeight( int height );
+
+ protected:
+ Point2f targetPosition;
+ int targetWidth;
+ int targetHeight;
+
+};
+
+/**
+ * \brief Represents the model of the target at frame k (all states and scores)
+ * [AAM] The set of the pair (x̄_k(i), C_k(i))
+ */
+typedef std::vector<std::pair<Ptr<TrackerTargetState>, float> > ConfidenceMap;
+
+/**
+ * \brief Represents the estimate states for all frames
+ * [AAM] Xk is the trajectory of the target up to time k
+ */
+typedef std::vector<Ptr<TrackerTargetState> > Trajectory;
+
+/**
+ * \brief Abstract base class for TrackerStateEstimator that estimates the most likely target state.
+ * [AAM] State estimator
+ * [AMVOT] Statistical modeling (Fig. 3), Table III (generative) - IV (discriminative) - V (hybrid)
+ */
+class CV_EXPORTS_W TrackerStateEstimator
+{
+ public:
+ virtual ~TrackerStateEstimator();
+
+ /**
+ * \brief Estimate the most likely target state
+ * \param confidenceMaps The overall appearance model
+ * \return The estimated state
+ */
+ Ptr<TrackerTargetState> estimate( const std::vector<ConfidenceMap>& confidenceMaps );
+
+ /**
+ * \brief Update the ConfidenceMap with the scores
+ * \param confidenceMaps The overall appearance model
+ */
+ void update( std::vector<ConfidenceMap>& confidenceMaps );
+
+ /**
+ * \brief Create TrackerStateEstimator by tracker state estimator type SVM - BOOSTING.
+ */
+ static Ptr<TrackerStateEstimator> create( const String& trackeStateEstimatorType );
+
+ /**
+ * \brief Get the name of the specific state estimator
+ * \return The name of the state estimator
+ */
+ String getClassName() const;
+
+ protected:
+
+ virtual Ptr<TrackerTargetState> estimateImpl( const std::vector<ConfidenceMap>& confidenceMaps ) = 0;
+ virtual void updateImpl( std::vector<ConfidenceMap>& confidenceMaps ) = 0;
+ String className;
+};
+
+/**
+ * \brief Abstract class that represents the model of the target. It must be instantiated by specialized tracker
+ * [AAM] Ak
+ */
+class CV_EXPORTS_W TrackerModel
+{
+ public:
+
+ /**
+ * \brief Constructor
+ */
+ TrackerModel();
+
+ /**
+ * \brief Destructor
+ */
+ virtual ~TrackerModel();
+
+ /**
+ * \brief Set TrackerEstimator
+ * \return true if the tracker state estimator is added, false otherwise
+ */
+ bool setTrackerStateEstimator( Ptr<TrackerStateEstimator> trackerStateEstimator );
+
+ /**
+ * \brief Estimate the most likely target location
+ * [AAM] ME, Model Estimation table I
+ * \param responses Features extracted
+ */
+ void modelEstimation( const std::vector<Mat>& responses );
+
+ /**
+ * \brief Update the model
+ * [AAM] MU, Model Update table I
+ */
+ void modelUpdate();
+
+ /**
+ * \brief Run the TrackerStateEstimator
+ * \return true if is possible to estimate a new state, false otherwise
+ */
+ bool runStateEstimator();
+
+ /**
+ * \brief Set the current estimated state
+ * \param lastTargetState the current estimated state
+ */
+ void setLastTargetState( const Ptr<TrackerTargetState>& lastTargetState );
+
+ /**
+ * \brief Get the last target state
+ * \return The last target state
+ */
+ Ptr<TrackerTargetState> getLastTargetState() const;
+
+ /**
+ * \brief Get the list of the confidence map
+ * \return The list of the confidence map
+ */
+ const std::vector<ConfidenceMap>& getConfidenceMaps() const;
+
+ /**
+ * \brief Get the last confidence map
+ * \return The the last confidence map
+ */
+ const ConfidenceMap& getLastConfidenceMap() const;
+
+ /**
+ * \brief Get the tracker state estimator
+ * \return The tracker state estimator
+ */
+ Ptr<TrackerStateEstimator> getTrackerStateEstimator() const;
+
+ private:
+
+ void clearCurrentConfidenceMap();
+
+ protected:
+ std::vector<ConfidenceMap> confidenceMaps;
+ Ptr<TrackerStateEstimator> stateEstimator;
+ ConfidenceMap currentConfidenceMap;
+ Trajectory trajectory;
+ int maxCMLength;
+
+ virtual void modelEstimationImpl( const std::vector<Mat>& responses ) = 0;
+ virtual void modelUpdateImpl() = 0;
+
+};
+
+/************************************ Tracker Base Class ************************************/
+
+/**
+ * \brief Abstract base class for Tracker algorithm.
+ */
+class CV_EXPORTS_W Tracker : public virtual Algorithm
+{
+ public:
+
+ virtual ~Tracker();
+
+ /**
+ * \brief Initialize the tracker at the first frame.
+ * \param image The image.
+ * \param boundingBox The bounding box.
+ * \return true the tracker is initialized, false otherwise
+ */
+ bool init( const Mat& image, const Rect& boundingBox );
+
+ /**
+ * \brief Update the tracker at the next frames.
+ * \param image The image.
+ * \param boundingBox The bounding box.
+ * \return true the tracker is updated, false otherwise
+ */
+ bool update( const Mat& image, Rect& boundingBox );
+
+ /**
+ * \brief Create tracker by tracker type MIL - BOOSTING.
+ */
+ static Ptr<Tracker> create( const String& trackerType );
+
+ protected:
+
+ virtual bool initImpl( const Mat& image, const Rect& boundingBox ) = 0;
+ virtual bool updateImpl( const Mat& image, Rect& boundingBox ) = 0;
+
+ bool isInit;
+
+ Ptr<TrackerFeatureSet> featureSet;
+ Ptr<TrackerSampler> sampler;
+ Ptr<TrackerModel> model;
+
+};
+
+/************************************ Specific TrackerStateEstimator Classes ************************************/
+
+/**
+ * \brief TrackerStateEstimator based on MILBoosting
+ */
+class CV_EXPORTS_W TrackerStateEstimatorMILBoosting : public TrackerStateEstimator
+{
+ public:
+
+ /**
+ * Implementation of the target state for TrackerStateEstimatorMILBoosting
+ */
+ class TrackerMILTargetState : public TrackerTargetState
+ {
+
+ public:
+ /**
+ * \brief Constructor
+ * \param position Top left corner of the bounding box
+ * \param width Width of the bounding box
+ * \param height Height of the bounding box
+ * \param foreground label for target or background
+ * \param features features extracted
+ */
+ TrackerMILTargetState( const Point2f& position, int width, int height, bool foreground, const Mat& features );
+
+ /**
+ * \brief Destructor
+ */
+ ~TrackerMILTargetState()
+ {
+ }
+ ;
+
+ /**
+ * setters and getters
+ */
+ void setTargetFg( bool foreground );
+ void setFeatures( const Mat& features );
+ bool isTargetFg() const;
+ Mat getFeatures() const;
+
+ private:
+ bool isTarget;
+ Mat targetFeatures;
+ };
+
+ TrackerStateEstimatorMILBoosting( int nFeatures = 250 );
+ ~TrackerStateEstimatorMILBoosting();
+
+ void setCurrentConfidenceMap( ConfidenceMap& confidenceMap );
+
+ protected:
+ Ptr<TrackerTargetState> estimateImpl( const std::vector<ConfidenceMap>& confidenceMaps );
+ void updateImpl( std::vector<ConfidenceMap>& confidenceMaps );
+
+ private:
+ uint max_idx( const std::vector<float> &v );
+ void prepareData( const ConfidenceMap& confidenceMap, Mat& positive, Mat& negative );
+
+ ClfMilBoost boostMILModel;
+ bool trained;
+ int numFeatures;
+
+ ConfidenceMap currentConfidenceMap;
+};
+
+/**
+ * \brief TrackerStateEstimator based on AdaBoosting
+ */
+class CV_EXPORTS_W TrackerStateEstimatorAdaBoosting : public TrackerStateEstimator
+{
+ public:
+ class TrackerAdaBoostingTargetState : public TrackerTargetState
+ {
+
+ public:
+ /**
+ * \brief Constructor
+ * \param position Top left corner of the bounding box
+ * \param width Width of the bounding box
+ * \param height Height of the bounding box
+ * \param foreground label for target or background
+ * \param responses list of features
+ */
+ TrackerAdaBoostingTargetState( const Point2f& position, int width, int height, bool foreground, const Mat& responses );
+
+ /**
+ * \brief Destructor
+ */
+ ~TrackerAdaBoostingTargetState()
+ {
+ }
+ ;
+
+ /**
+ * setters and getters
+ */
+ void setTargetResponses( const Mat& responses );
+ void setTargetFg( bool foreground );
+ Mat getTargetResponses() const;
+ bool isTargetFg() const;
+
+ private:
+ bool isTarget;
+ Mat targetResponses;
+
+ };
+
+ /**
+ * \brief Constructor
+ * \param numClassifer Number of base classifiers
+ * \param initIterations Number of iterations in the initialization
+ * \param nFeatures Number of features/weak classifiers
+ * \param patchSize tracking rect
+ * \param ROI initial ROI
+ */
+ TrackerStateEstimatorAdaBoosting( int numClassifer, int initIterations, int nFeatures, Size patchSize, const Rect& ROI );
+
+ /**
+ * \brief Destructor
+ */
+ ~TrackerStateEstimatorAdaBoosting();
+
+ /**
+ * \brief Get the sampling ROI
+ * \return the sampling ROI
+ */
+ Rect getSampleROI() const;
+
+ /**
+ * \brief Set the sampling ROI
+ * \param ROI the sampling ROI
+ */
+ void setSampleROI( const Rect& ROI );
+
+ /**
+ * \brief Set the current confidence map
+ * \param confidenceMap the current confidence map
+ */
+ void setCurrentConfidenceMap( ConfidenceMap& confidenceMap );
+
+ /**
+ * \brief Get the list of the selected weak classifiers for the classification step
+ * \return the list of the selected weak classifiers
+ */
+ std::vector<int> computeSelectedWeakClassifier();
+
+ /**
+ * \brief Get the list of the weak classifiers that should be replaced
+ * \return the list of the weak classifiers
+ */
+ std::vector<int> computeReplacedClassifier();
+
+ /**
+ * \brief Get the list of the weak classifiers that replace those to be replaced
+ * \return the list of the weak classifiers
+ */
+ std::vector<int> computeSwappedClassifier();
+
+ protected:
+ Ptr<TrackerTargetState> estimateImpl( const std::vector<ConfidenceMap>& confidenceMaps );
+ void updateImpl( std::vector<ConfidenceMap>& confidenceMaps );
+
+ Ptr<StrongClassifierDirectSelection> boostClassifier;
+
+ private:
+ int numBaseClassifier;
+ int iterationInit;
+ int numFeatures;
+ bool trained;
+ Size initPatchSize;
+ Rect sampleROI;
+ std::vector<int> replacedClassifier;
+ std::vector<int> swappedClassifier;
+
+ ConfidenceMap currentConfidenceMap;
+};
+
+/**
+ * \brief TrackerStateEstimator based on SVM
+ */
+class CV_EXPORTS_W TrackerStateEstimatorSVM : public TrackerStateEstimator
+{
+ public:
+ TrackerStateEstimatorSVM();
+ ~TrackerStateEstimatorSVM();
+
+ protected:
+ Ptr<TrackerTargetState> estimateImpl( const std::vector<ConfidenceMap>& confidenceMaps );
+ void updateImpl( std::vector<ConfidenceMap>& confidenceMaps );
+};
+
+/************************************ Specific TrackerSamplerAlgorithm Classes ************************************/
+
+/**
+ * \brief TrackerSampler based on CSC (current state centered)
+ */
+class CV_EXPORTS_W TrackerSamplerCSC : public TrackerSamplerAlgorithm
+{
+ public:
+ enum
+ {
+ MODE_INIT_POS = 1, // mode for init positive samples
+ MODE_INIT_NEG = 2, // mode for init negative samples
+ MODE_TRACK_POS = 3, // mode for update positive samples
+ MODE_TRACK_NEG = 4, // mode for update negative samples
+ MODE_DETECT = 5 // mode for detect samples
+ };
+
+ struct CV_EXPORTS Params
+ {
+ Params();
+ float initInRad; // radius for gathering positive instances during init
+ float trackInPosRad; // radius for gathering positive instances during tracking
+ float searchWinSize; // size of search window
+ int initMaxNegNum; // # negative samples to use during init
+ int trackMaxPosNum; // # positive samples to use during training
+ int trackMaxNegNum; // # negative samples to use during training
+ };
+
+ TrackerSamplerCSC( const TrackerSamplerCSC::Params ¶meters = TrackerSamplerCSC::Params() );
+
+ /**
+ * \brief set the sampling mode
+ */
+ void setMode( int samplingMode );
+
+ ~TrackerSamplerCSC();
+
+ protected:
+
+ bool samplingImpl( const Mat& image, Rect boundingBox, std::vector<Mat>& sample );
+
+ private:
+
+ Params params;
+ int mode;
+ RNG rng;
+
+ std::vector<Mat> sampleImage( const Mat& img, int x, int y, int w, int h, float inrad, float outrad = 0, int maxnum = 1000000 );
+};
+
+/**
+ * \brief TrackerSampler based on CS (current state)
+ */
+class CV_EXPORTS_W TrackerSamplerCS : public TrackerSamplerAlgorithm
+{
+ public:
+ enum
+ {
+ MODE_POSITIVE = 1, // mode for positive samples
+ MODE_NEGATIVE = 2, // mode for negative samples
+ MODE_CLASSIFY = 3 // mode for classify samples
+ };
+
+ struct CV_EXPORTS Params
+ {
+ Params();
+ float overlap; //overlapping for the search windows
+ float searchFactor; //search region parameter
+ };
+ TrackerSamplerCS( const TrackerSamplerCS::Params ¶meters = TrackerSamplerCS::Params() );
+
+ /**
+ * \brief set the sampling mode
+ */
+ void setMode( int samplingMode );
+
+ ~TrackerSamplerCS();
+
+ bool samplingImpl( const Mat& image, Rect boundingBox, std::vector<Mat>& sample );
+ Rect getROI() const;
+ private:
+ Rect getTrackingROI( float searchFactor );
+ Rect RectMultiply( const Rect & rect, float f );
+ std::vector<Mat> patchesRegularScan( const Mat& image, Rect trackingROI, Size patchSize );
+ void setCheckedROI( Rect imageROI );
+
+ Params params;
+ int mode;
+ Rect trackedPatch;
+ Rect validROI;
+ Rect ROI;
+
+};
+
+/************************************ Specific TrackerFeature Classes ************************************/
+
+/**
+ * \brief TrackerFeature based on Feature2D
+ */
+class CV_EXPORTS_W TrackerFeatureFeature2d : public TrackerFeature
+{
+ public:
+
+ /**
+ * \brief Constructor
+ * \param detectorType string of FeatureDetector
+ * \param descriptorType string of DescriptorExtractor
+ */
+ TrackerFeatureFeature2d( String detectorType, String descriptorType );
+
+ ~TrackerFeatureFeature2d();
+
+ void selection( Mat& response, int npoints );
+
+ protected:
+
+ bool computeImpl( const std::vector<Mat>& images, Mat& response );
+
+ private:
+
+ std::vector<KeyPoint> keypoints;
+};
+
+/**
+ * \brief TrackerFeature based on HOG
+ */
+class CV_EXPORTS_W TrackerFeatureHOG : public TrackerFeature
+{
+ public:
+
+ TrackerFeatureHOG();
+
+ ~TrackerFeatureHOG();
+
+ void selection( Mat& response, int npoints );
+
+ protected:
+
+ bool computeImpl( const std::vector<Mat>& images, Mat& response );
+
+};
+
+/**
+ * \brief TrackerFeature based on HAAR
+ */
+class CV_EXPORTS_W TrackerFeatureHAAR : public TrackerFeature
+{
+ public:
+ struct CV_EXPORTS Params
+ {
+ Params();
+ int numFeatures; // # of rects
+ Size rectSize; // rect size
+ bool isIntegral; // true if input images are integral, false otherwise
+ };
+
+ TrackerFeatureHAAR( const TrackerFeatureHAAR::Params ¶meters = TrackerFeatureHAAR::Params() );
+
+ ~TrackerFeatureHAAR();
+
+ /**
+ * \brief Compute the features only for the selected indices in the images collection
+ * \param selFeatures indices of selected features
+ * \param images The images.
+ * \param response Computed features.
+ */
+ bool extractSelected( const std::vector<int> selFeatures, const std::vector<Mat>& images, Mat& response );
+
+ void selection( Mat& response, int npoints );
+
+ /**
+ * \brief Swap the feature in position source with the feature in position target
+ * \param source The source position
+ * \param target The target position
+ */
+ bool swapFeature( int source, int target );
+
+ /**
+ * \brief Swap the feature in position id with the feature input
+ * \param id The position
+ * \param feature The feature
+ */
+ bool swapFeature( int id, CvHaarEvaluator::FeatureHaar& feature );
+
+ /**
+ * \brief Get the feature
+ * \param id The position
+ * \return the feature in position id
+ */
+ CvHaarEvaluator::FeatureHaar& getFeatureAt( int id );
+
+ protected:
+ bool computeImpl( const std::vector<Mat>& images, Mat& response );
+
+ private:
+
+ Params params;
+ Ptr<CvHaarEvaluator> featureEvaluator;
+};
+
+/**
+ * \brief TrackerFeature based on LBP
+ */
+class CV_EXPORTS_W TrackerFeatureLBP : public TrackerFeature
+{
+ public:
+
+ TrackerFeatureLBP();
+
+ ~TrackerFeatureLBP();
+
+ void selection( Mat& response, int npoints );
+
+ protected:
+
+ bool computeImpl( const std::vector<Mat>& images, Mat& response );
+
+};
+
+/************************************ Specific Tracker Classes ************************************/
+
+/**
+ \brief TrackerMIL implementation.
+ For more details see B Babenko, MH Yang, S Belongie, Visual Tracking with Online Multiple Instance Learning
+ */
+
+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;
+ };
+
+ /**
+ * \brief TrackerMIL Constructor
+ * \param parameters TrackerMIL parameters
+ */
+ TrackerMIL( const TrackerMIL::Params ¶meters = TrackerMIL::Params() );
+
+ virtual ~TrackerMIL();
+
+ void read( const FileNode& fn );
+ void write( FileStorage& fs ) const;
+
+ protected:
+
+ bool initImpl( const Mat& image, const Rect& boundingBox );
+ bool updateImpl( const Mat& image, Rect& boundingBox );
+ void compute_integral( const Mat & img, Mat & ii_img );
+
+ Params params;
+ AlgorithmInfo* info() const;
+
+};
+
+/**
+ \brief TrackerBoosting implementation.
+ For more details see H Grabner, M Grabner, H Bischof, Real-time tracking via on-line boosting
+ */
+class CV_EXPORTS_W TrackerBoosting : public Tracker
+{
+ public:
+ struct CV_EXPORTS Params
+ {
+ Params();
+ int numClassifiers; //the number of classifiers to use in a OnlineBoosting algorithm
+ float samplerOverlap; //search region parameters to use in a OnlineBoosting algorithm
+ float samplerSearchFactor; // search region parameters to use in a OnlineBoosting algorithm
+ int iterationInit; //the initial iterations
+ int featureSetNumFeatures; // #features
+ /**
+ * \brief Read parameters from file
+ */
+ void read( const FileNode& fn );
+
+ /**
+ * \brief Write parameters in a file
+ */
+ void write( FileStorage& fs ) const;
+ };
+
+ /**
+ * \brief TrackerBoosting Constructor
+ * \param parameters TrackerBoosting parameters
+ */
+ TrackerBoosting( const TrackerBoosting::Params ¶meters = TrackerBoosting::Params() );
+
+ virtual ~TrackerBoosting();
+
+ void read( const FileNode& fn );
+ void write( FileStorage& fs ) const;
+
+ protected:
+
+ bool initImpl( const Mat& image, const Rect& boundingBox );
+ bool updateImpl( const Mat& image, Rect& boundingBox );
+
+ Params params;
+ AlgorithmInfo* info() const;
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/modules/tracking/include/opencv2/tracking/tracking.hpp b/modules/tracking/include/opencv2/tracking/tracking.hpp
new file mode 100644
index 000000000..eb098e27b
--- /dev/null
+++ b/modules/tracking/include/opencv2/tracking/tracking.hpp
@@ -0,0 +1,46 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/tracking.hpp"
diff --git a/modules/tracking/perf/perf_main.cpp b/modules/tracking/perf/perf_main.cpp
new file mode 100644
index 000000000..de3cc39b7
--- /dev/null
+++ b/modules/tracking/perf/perf_main.cpp
@@ -0,0 +1,3 @@
+#include "perf_precomp.hpp"
+
+CV_PERF_TEST_MAIN(tracking)
diff --git a/modules/tracking/perf/perf_precomp.hpp b/modules/tracking/perf/perf_precomp.hpp
new file mode 100644
index 000000000..8c4987a5d
--- /dev/null
+++ b/modules/tracking/perf/perf_precomp.hpp
@@ -0,0 +1,21 @@
+#ifdef __GNUC__
+# pragma GCC diagnostic ignored "-Wmissing-declarations"
+# if defined __clang__ || defined __APPLE__
+# pragma GCC diagnostic ignored "-Wmissing-prototypes"
+# pragma GCC diagnostic ignored "-Wextra"
+# endif
+#endif
+
+#ifndef __OPENCV_TRACKING_PRECOMP_HPP__
+#define __OPENCV_TRACKING_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include <opencv2/imgproc.hpp>
+#include <opencv2/tracking.hpp>
+#include <opencv2/highgui.hpp>
+
+#ifdef GTEST_CREATE_SHARED_LIBRARY
+#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
+#endif
+
+#endif
diff --git a/modules/tracking/perf/perf_tracking.cpp b/modules/tracking/perf/perf_tracking.cpp
new file mode 100644
index 000000000..c143a62ce
--- /dev/null
+++ b/modules/tracking/perf/perf_tracking.cpp
@@ -0,0 +1,46 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace perf;
diff --git a/modules/tracking/samples/tracker.cpp b/modules/tracking/samples/tracker.cpp
new file mode 100644
index 000000000..80ef98f90
--- /dev/null
+++ b/modules/tracking/samples/tracker.cpp
@@ -0,0 +1,148 @@
+#include <opencv2/core/utility.hpp>
+#include <opencv2/tracking.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static Mat image;
+static Rect boundingBox;
+static bool paused;
+static bool selectObject = false;
+static bool startSelection = false;
+
+static const char* keys =
+{ "{@tracker_algorithm | | tracker algorithm }"
+ "{@video_name | | video name }" };
+
+static void help()
+{
+ cout << "\nThis example shows the functionality of \"Long-term optical tracking API\""
+ "-- pause video [p] and draw a bounding box around the target to start the tracker\n"
+ "Call:\n"
+ "./tracker <tracker_algorithm> <video_name>\n"
+ << endl;
+
+ cout << "\n\nHot keys: \n"
+ "\tq - quit the program\n"
+ "\tp - pause video\n";
+}
+
+static void onMouse( int event, int x, int y, int, void* )
+{
+ if( !selectObject )
+ {
+ switch ( event )
+ {
+ case EVENT_LBUTTONDOWN:
+ //set origin of the bounding box
+ startSelection = true;
+ boundingBox.x = x;
+ boundingBox.y = y;
+ break;
+ case EVENT_LBUTTONUP:
+ //sei with and height of the bounding box
+ boundingBox.width = std::abs( x - boundingBox.x );
+ boundingBox.height = std::abs( y - boundingBox.y );
+ paused = false;
+ selectObject = true;
+ break;
+ case EVENT_MOUSEMOVE:
+
+ if( startSelection && !selectObject )
+ {
+ //draw the bounding box
+ Mat currentFrame;
+ image.copyTo( currentFrame );
+ rectangle( currentFrame, Point( boundingBox.x, boundingBox.y ), Point( x, y ), Scalar( 255, 0, 0 ), 2, 1 );
+ imshow( "Tracking API", currentFrame );
+ }
+ break;
+ }
+ }
+}
+
+int main( int argc, char** argv )
+{
+ CommandLineParser parser( argc, argv, keys );
+
+ String tracker_algorithm = parser.get<String>( 0 );
+ String video_name = parser.get<String>( 1 );
+
+ if( tracker_algorithm.empty() || video_name.empty() )
+ {
+ help();
+ return -1;
+ }
+
+ //open the capture
+ VideoCapture cap;
+ cap.open( video_name );
+
+ if( !cap.isOpened() )
+ {
+ help();
+ cout << "***Could not initialize capturing...***\n";
+ cout << "Current parameter's value: \n";
+ parser.printMessage();
+ return -1;
+ }
+
+ Mat frame;
+ paused = true;
+ namedWindow( "Tracking API", 1 );
+ setMouseCallback( "Tracking API", onMouse, 0 );
+
+ //instantiates the specific Tracker
+ Ptr<Tracker> tracker = Tracker::create( tracker_algorithm );
+ if( tracker == NULL )
+ {
+ cout << "***Error in the instantiation of the tracker...***\n";
+ return -1;
+ }
+
+ //get the first frame
+ cap >> frame;
+ frame.copyTo( image );
+ imshow( "Tracking API", image );
+
+ bool initialized = false;
+ for ( ;; )
+ {
+ if( !paused )
+ {
+ cap >> frame;
+ frame.copyTo( image );
+
+ if( !initialized && selectObject )
+ {
+ //initializes the tracker
+ if( !tracker->init( frame, boundingBox ) )
+ {
+ cout << "***Could not initialize tracker...***\n";
+ return -1;
+ }
+ initialized = true;
+ }
+ else if( initialized )
+ {
+ //updates the tracker
+ if( tracker->update( frame, boundingBox ) )
+ {
+ rectangle( image, boundingBox, Scalar( 255, 0, 0 ), 2, 1 );
+ }
+ }
+ imshow( "Tracking API", image );
+ }
+
+ char c = (char) waitKey( 2 );
+ if( c == 'q' )
+ break;
+ if( c == 'p' )
+ paused = !paused;
+
+ }
+
+ return 0;
+}
diff --git a/modules/tracking/src/feature.cpp b/modules/tracking/src/feature.cpp
new file mode 100644
index 000000000..64995a640
--- /dev/null
+++ b/modules/tracking/src/feature.cpp
@@ -0,0 +1,1072 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include "opencv2/tracking/feature.hpp"
+
+namespace cv
+{
+
+/*
+ * TODO This implementation is based on apps/traincascade/
+ * TODO Changed CvHaarEvaluator based on ADABOOSTING implementation (Grabner et al.)
+ */
+
+CvParams::CvParams() :
+ name( "params" )
+{
+}
+void CvParams::printDefaults() const
+{
+ std::cout << "--" << name << "--" << std::endl;
+}
+void CvParams::printAttrs() const
+{
+}
+bool CvParams::scanAttr( const std::string, const std::string )
+{
+ return false;
+}
+
+//---------------------------- FeatureParams --------------------------------------
+
+CvFeatureParams::CvFeatureParams() :
+ maxCatCount( 0 ),
+ featSize( 1 ),
+ numFeatures( 1 )
+{
+ name = CC_FEATURE_PARAMS;
+}
+
+void CvFeatureParams::init( const CvFeatureParams& fp )
+{
+ maxCatCount = fp.maxCatCount;
+ featSize = fp.featSize;
+ numFeatures = fp.numFeatures;
+}
+
+void CvFeatureParams::write( FileStorage &fs ) const
+{
+ fs << CC_MAX_CAT_COUNT << maxCatCount;
+ fs << CC_FEATURE_SIZE << featSize;
+ fs << CC_NUM_FEATURES << numFeatures;
+}
+
+bool CvFeatureParams::read( const FileNode &node )
+{
+ if( node.empty() )
+ return false;
+ maxCatCount = node[CC_MAX_CAT_COUNT];
+ featSize = node[CC_FEATURE_SIZE];
+ numFeatures = node[CC_NUM_FEATURES];
+ return ( maxCatCount >= 0 && featSize >= 1 );
+}
+
+Ptr<CvFeatureParams> CvFeatureParams::create( int featureType )
+{
+ return featureType == HAAR ? Ptr<CvFeatureParams>( new CvHaarFeatureParams ) : featureType == LBP ? Ptr<CvFeatureParams>( new CvLBPFeatureParams ) :
+ featureType == HOG ? Ptr<CvFeatureParams>( new CvHOGFeatureParams ) : Ptr<CvFeatureParams>();
+}
+
+//------------------------------------- FeatureEvaluator ---------------------------------------
+
+void CvFeatureEvaluator::init( const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize )
+{
+ CV_Assert( _maxSampleCount > 0 );
+ featureParams = (CvFeatureParams *) _featureParams;
+ winSize = _winSize;
+ numFeatures = _featureParams->numFeatures;
+ cls.create( (int) _maxSampleCount, 1, CV_32FC1 );
+ generateFeatures();
+}
+
+void CvFeatureEvaluator::setImage( const Mat &img, uchar clsLabel, int idx )
+{
+ winSize.width = img.cols;
+ winSize.height = img.rows;
+ //CV_Assert( img.cols == winSize.width );
+ //CV_Assert( img.rows == winSize.height );
+ CV_Assert( idx < cls.rows );
+ cls.ptr<float>( idx )[0] = clsLabel;
+}
+
+Ptr<CvFeatureEvaluator> CvFeatureEvaluator::create( int type )
+{
+ return type == CvFeatureParams::HAAR ? Ptr<CvFeatureEvaluator>( new CvHaarEvaluator ) :
+ type == CvFeatureParams::LBP ? Ptr<CvFeatureEvaluator>( new CvLBPEvaluator ) :
+ type == CvFeatureParams::HOG ? Ptr<CvFeatureEvaluator>( new CvHOGEvaluator ) : Ptr<CvFeatureEvaluator>();
+}
+
+CvHaarFeatureParams::CvHaarFeatureParams()
+{
+ name = HFP_NAME;
+ isIntegral = false;
+}
+
+void CvHaarFeatureParams::init( const CvFeatureParams& fp )
+{
+ CvFeatureParams::init( fp );
+ isIntegral = ( (const CvHaarFeatureParams&) fp ).isIntegral;
+}
+
+void CvHaarFeatureParams::write( FileStorage &fs ) const
+{
+ CvFeatureParams::write( fs );
+ fs << CC_ISINTEGRAL << isIntegral;
+}
+
+bool CvHaarFeatureParams::read( const FileNode &node )
+{
+ if( !CvFeatureParams::read( node ) )
+ return false;
+
+ FileNode rnode = node[CC_ISINTEGRAL];
+ if( !rnode.isString() )
+ return false;
+ String intStr;
+ rnode >> intStr;
+ isIntegral = !intStr.compare( "0" ) ? false : !true;
+ return true;
+}
+
+void CvHaarFeatureParams::printDefaults() const
+{
+ CvFeatureParams::printDefaults();
+ std::cout << "isIntegral: false" << std::endl;
+}
+
+void CvHaarFeatureParams::printAttrs() const
+{
+ CvFeatureParams::printAttrs();
+ std::string int_str = isIntegral == true ? "true" : "false";
+ std::cout << "isIntegral: " << int_str << std::endl;
+}
+
+bool CvHaarFeatureParams::scanAttr( const std::string /*prmName*/, const std::string /*val*/)
+{
+
+ return true;
+}
+
+//--------------------- HaarFeatureEvaluator ----------------
+
+void CvHaarEvaluator::init( const CvFeatureParams *_featureParams, int /*_maxSampleCount*/, Size _winSize )
+{
+ int cols = ( _winSize.width + 1 ) * ( _winSize.height + 1 );
+ sum.create( (int) 1, cols, CV_32SC1 );
+ isIntegral = ( (CvHaarFeatureParams*) _featureParams )->isIntegral;
+ CvFeatureEvaluator::init( _featureParams, 1, _winSize );
+}
+
+void CvHaarEvaluator::setImage( const Mat& img, uchar /*clsLabel*/, int /*idx*/)
+{
+ CV_DbgAssert( !sum.empty() );
+
+ winSize.width = img.cols;
+ winSize.height = img.rows;
+
+ CvFeatureEvaluator::setImage( img, 1, 0 );
+ if( !isIntegral )
+ {
+ std::vector<Mat_<float> > ii_imgs;
+ compute_integral( img, ii_imgs );
+ _ii_img = ii_imgs[0];
+ }
+ else
+ {
+ _ii_img = img;
+ }
+}
+
+void CvHaarEvaluator::writeFeatures( FileStorage &fs, const Mat& featureMap ) const
+{
+ _writeFeatures( features, fs, featureMap );
+}
+
+void CvHaarEvaluator::writeFeature( FileStorage &fs ) const
+{
+ String modeStr = isIntegral == true ? "1" : "0";
+ CV_Assert( !modeStr.empty() );
+ fs << "isIntegral" << modeStr;
+}
+
+void CvHaarEvaluator::generateFeatures()
+{
+ generateFeatures( featureParams->numFeatures );
+}
+
+void CvHaarEvaluator::generateFeatures( int nFeatures )
+{
+ for ( int i = 0; i < nFeatures; i++ )
+ {
+ CvHaarEvaluator::FeatureHaar feature( Size( winSize.width, winSize.height ) );
+ features.push_back( feature );
+ }
+
+}
+
+const std::vector<CvHaarEvaluator::FeatureHaar>& CvHaarEvaluator::getFeatures() const
+{
+ return features;
+}
+
+float CvHaarEvaluator::operator()( int featureIdx, int /*sampleIdx*/)
+{
+ /* TODO Added from MIL implementation */
+ //return features[featureIdx].calc( _ii_img, Mat(), 0 );
+ float res;
+ features.at( featureIdx ).eval( _ii_img, Rect( 0, 0, winSize.width, winSize.height ), &res );
+ return res;
+}
+
+void CvHaarEvaluator::setWinSize( Size patchSize )
+{
+ winSize.width = patchSize.width;
+ winSize.height = patchSize.height;
+}
+
+Size CvHaarEvaluator::setWinSize() const
+{
+ return Size( winSize.width, winSize.height );
+}
+
+#define INITSIGMA( numAreas ) ( static_cast<float>( sqrt( 256.0f*256.0f / 12.0f * (numAreas) ) ) );
+
+CvHaarEvaluator::FeatureHaar::FeatureHaar( Size patchSize )
+{
+ try
+ {
+ generateRandomFeature( patchSize );
+ }
+ catch ( ... )
+ {
+ throw;
+ }
+}
+
+float CvHaarEvaluator::FeatureHaar::getInitMean() const
+{
+ return m_initMean;
+}
+
+float CvHaarEvaluator::FeatureHaar::getInitSigma() const
+{
+ return m_initSigma;
+}
+
+void CvHaarEvaluator::FeatureHaar::generateRandomFeature( Size patchSize )
+{
+ cv::Point2i position;
+ Size baseDim;
+ Size sizeFactor;
+ int area;
+
+ //Size minSize = Size( 3, 3 );
+ int minArea = 9;
+
+ bool valid = false;
+ while ( !valid )
+ {
+ //choose position and scale
+ position.y = rand() % ( patchSize.height );
+ position.x = rand() % ( patchSize.width );
+
+ baseDim.width = (int) ( ( 1 - sqrt( 1 - (float) rand() / RAND_MAX ) ) * patchSize.width );
+ baseDim.height = (int) ( ( 1 - sqrt( 1 - (float) rand() / RAND_MAX ) ) * patchSize.height );
+
+ //select types
+ //float probType[11] = {0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0950f};
+ float probType[11] =
+ { 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+ float prob = (float) rand() / RAND_MAX;
+
+ if( prob < probType[0] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 2;
+ sizeFactor.width = 1;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 1;
+ m_numAreas = 2;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x;
+ m_areas[1].y = position.y + baseDim.height;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_initMean = 0;
+ m_initSigma = INITSIGMA( m_numAreas );
+
+ valid = true;
+
+ }
+ else if( prob < probType[0] + probType[1] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 1;
+ sizeFactor.width = 2;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 2;
+ m_numAreas = 2;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x + baseDim.width;
+ m_areas[1].y = position.y;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_initMean = 0;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+
+ }
+ else if( prob < probType[0] + probType[1] + probType[2] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 4;
+ sizeFactor.width = 1;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 3;
+ m_numAreas = 3;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -2;
+ m_weights[2] = 1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x;
+ m_areas[1].y = position.y + baseDim.height;
+ m_areas[1].height = 2 * baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_areas[2].y = position.y + 3 * baseDim.height;
+ m_areas[2].x = position.x;
+ m_areas[2].height = baseDim.height;
+ m_areas[2].width = baseDim.width;
+ m_initMean = 0;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else if( prob < probType[0] + probType[1] + probType[2] + probType[3] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 1;
+ sizeFactor.width = 4;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 3;
+ m_numAreas = 3;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -2;
+ m_weights[2] = 1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x + baseDim.width;
+ m_areas[1].y = position.y;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = 2 * baseDim.width;
+ m_areas[2].y = position.y;
+ m_areas[2].x = position.x + 3 * baseDim.width;
+ m_areas[2].height = baseDim.height;
+ m_areas[2].width = baseDim.width;
+ m_initMean = 0;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 2;
+ sizeFactor.width = 2;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 5;
+ m_numAreas = 4;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -1;
+ m_weights[2] = -1;
+ m_weights[3] = 1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x + baseDim.width;
+ m_areas[1].y = position.y;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_areas[2].y = position.y + baseDim.height;
+ m_areas[2].x = position.x;
+ m_areas[2].height = baseDim.height;
+ m_areas[2].width = baseDim.width;
+ m_areas[3].y = position.y + baseDim.height;
+ m_areas[3].x = position.x + baseDim.width;
+ m_areas[3].height = baseDim.height;
+ m_areas[3].width = baseDim.width;
+ m_initMean = 0;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 3;
+ sizeFactor.width = 3;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 6;
+ m_numAreas = 2;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -9;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = 3 * baseDim.height;
+ m_areas[0].width = 3 * baseDim.width;
+ m_areas[1].x = position.x + baseDim.width;
+ m_areas[1].y = position.y + baseDim.height;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_initMean = -8 * 128;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 3;
+ sizeFactor.width = 1;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 7;
+ m_numAreas = 3;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -2;
+ m_weights[2] = 1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x;
+ m_areas[1].y = position.y + baseDim.height;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_areas[2].y = position.y + baseDim.height * 2;
+ m_areas[2].x = position.x;
+ m_areas[2].height = baseDim.height;
+ m_areas[2].width = baseDim.width;
+ m_initMean = 0;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 1;
+ sizeFactor.width = 3;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+
+ if( area < minArea )
+ continue;
+
+ m_type = 8;
+ m_numAreas = 3;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -2;
+ m_weights[2] = 1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x + baseDim.width;
+ m_areas[1].y = position.y;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_areas[2].y = position.y;
+ m_areas[2].x = position.x + 2 * baseDim.width;
+ m_areas[2].height = baseDim.height;
+ m_areas[2].width = baseDim.width;
+ m_initMean = 0;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 3;
+ sizeFactor.width = 3;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 9;
+ m_numAreas = 2;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -2;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = 3 * baseDim.height;
+ m_areas[0].width = 3 * baseDim.width;
+ m_areas[1].x = position.x + baseDim.width;
+ m_areas[1].y = position.y + baseDim.height;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_initMean = 0;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else if( prob
+ < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8] + probType[9] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 3;
+ sizeFactor.width = 1;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 10;
+ m_numAreas = 3;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -1;
+ m_weights[2] = 1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x;
+ m_areas[1].y = position.y + baseDim.height;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_areas[2].y = position.y + baseDim.height * 2;
+ m_areas[2].x = position.x;
+ m_areas[2].height = baseDim.height;
+ m_areas[2].width = baseDim.width;
+ m_initMean = 128;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else if( prob
+ < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8] + probType[9]
+ + probType[10] )
+ {
+ //check if feature is valid
+ sizeFactor.height = 1;
+ sizeFactor.width = 3;
+ if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
+ continue;
+ area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+ if( area < minArea )
+ continue;
+
+ m_type = 11;
+ m_numAreas = 3;
+ m_weights.resize( m_numAreas );
+ m_weights[0] = 1;
+ m_weights[1] = -1;
+ m_weights[2] = 1;
+ m_areas.resize( m_numAreas );
+ m_areas[0].x = position.x;
+ m_areas[0].y = position.y;
+ m_areas[0].height = baseDim.height;
+ m_areas[0].width = baseDim.width;
+ m_areas[1].x = position.x + baseDim.width;
+ m_areas[1].y = position.y;
+ m_areas[1].height = baseDim.height;
+ m_areas[1].width = baseDim.width;
+ m_areas[2].y = position.y;
+ m_areas[2].x = position.x + 2 * baseDim.width;
+ m_areas[2].height = baseDim.height;
+ m_areas[2].width = baseDim.width;
+ m_initMean = 128;
+ m_initSigma = INITSIGMA( m_numAreas );
+ valid = true;
+ }
+ else
+ CV_Assert( false );
+ }
+
+ m_initSize = patchSize;
+ m_curSize = m_initSize;
+ m_scaleFactorWidth = m_scaleFactorHeight = 1.0f;
+ m_scaleAreas.resize( m_numAreas );
+ m_scaleWeights.resize( m_numAreas );
+ for ( int curArea = 0; curArea < m_numAreas; curArea++ )
+ {
+ m_scaleAreas[curArea] = m_areas[curArea];
+ m_scaleWeights[curArea] = (float) m_weights[curArea] / (float) ( m_areas[curArea].width * m_areas[curArea].height );
+ }
+}
+
+bool CvHaarEvaluator::FeatureHaar::eval( const Mat& image, Rect /*ROI*/, float* result ) const
+{
+
+ *result = 0.0f;
+
+ for ( int curArea = 0; curArea < m_numAreas; curArea++ )
+ {
+ *result += (float) getSum( image, Rect( m_areas[curArea].x, m_areas[curArea].y, m_areas[curArea].width, m_areas[curArea].height ) )
+ * m_scaleWeights[curArea];
+ }
+
+ /*
+ if( image->getUseVariance() )
+ {
+ float variance = (float) image->getVariance( ROI );
+ *result /= variance;
+ }
+ */
+
+ return true;
+}
+
+float CvHaarEvaluator::FeatureHaar::getSum( const Mat& image, Rect imageROI ) const
+{
+// left upper Origin
+ int OriginX = imageROI.x;
+ int OriginY = imageROI.y;
+
+// Check and fix width and height
+ int Width = imageROI.width;
+ int Height = imageROI.height;
+
+ if( OriginX + Width >= image.cols - 1 )
+ Width = ( image.cols - 1 ) - OriginX;
+ if( OriginY + Height >= image.rows - 1 )
+ Height = ( image.rows - 1 ) - OriginY;
+
+ float value = 0;
+ int depth = image.depth();
+
+ if( depth == CV_8U || depth == CV_32S )
+ value = image.at<int>( OriginY + Height, OriginX + Width ) + image.at<int>( OriginY, OriginX ) - image.at<int>( OriginY, OriginX + Width )
+ - image.at<int>( OriginY + Height, OriginX );
+ else if( depth == CV_64F )
+ value = image.at<double>( OriginY + Height, OriginX + Width ) + image.at<double>( OriginY, OriginX )
+ - image.at<double>( OriginY, OriginX + Width ) - image.at<double>( OriginY + Height, OriginX );
+ else if( depth == CV_32F )
+ value = image.at<float>( OriginY + Height, OriginX + Width ) + image.at<float>( OriginY, OriginX ) - image.at<float>( OriginY, OriginX + Width )
+ - image.at<float>( OriginY + Height, OriginX );
+
+ return value;
+}
+
+int CvHaarEvaluator::FeatureHaar::getNumAreas()
+{
+ return m_numAreas;
+}
+
+const std::vector<float>& CvHaarEvaluator::FeatureHaar::getWeights() const
+{
+ return m_weights;
+}
+
+const std::vector<Rect>& CvHaarEvaluator::FeatureHaar::getAreas() const
+{
+ return m_areas;
+}
+
+CvHOGFeatureParams::CvHOGFeatureParams()
+{
+ maxCatCount = 0;
+ name = HOGF_NAME;
+ featSize = N_BINS * N_CELLS;
+}
+
+void CvHOGEvaluator::init( const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize )
+{
+ CV_Assert( _maxSampleCount > 0 );
+ int cols = ( _winSize.width + 1 ) * ( _winSize.height + 1 );
+ for ( int bin = 0; bin < N_BINS; bin++ )
+ {
+ hist.push_back( Mat( _maxSampleCount, cols, CV_32FC1 ) );
+ }
+ normSum.create( (int) _maxSampleCount, cols, CV_32FC1 );
+ CvFeatureEvaluator::init( _featureParams, _maxSampleCount, _winSize );
+}
+
+void CvHOGEvaluator::setImage( const Mat &img, uchar clsLabel, int idx )
+{
+ CV_DbgAssert( !hist.empty());
+ CvFeatureEvaluator::setImage( img, clsLabel, idx );
+ std::vector<Mat> integralHist;
+ for ( int bin = 0; bin < N_BINS; bin++ )
+ {
+ integralHist.push_back( Mat( winSize.height + 1, winSize.width + 1, hist[bin].type(), hist[bin].ptr<float>( (int) idx ) ) );
+ }
+ Mat integralNorm( winSize.height + 1, winSize.width + 1, normSum.type(), normSum.ptr<float>( (int) idx ) );
+ integralHistogram( img, integralHist, integralNorm, (int) N_BINS );
+}
+
+//void CvHOGEvaluator::writeFeatures( FileStorage &fs, const Mat& featureMap ) const
+//{
+// _writeFeatures( features, fs, featureMap );
+//}
+
+void CvHOGEvaluator::writeFeatures( FileStorage &fs, const Mat& featureMap ) const
+{
+ int featIdx;
+ int componentIdx;
+ const Mat_<int>& featureMap_ = (const Mat_<int>&) featureMap;
+ fs << FEATURES << "[";
+ for ( int fi = 0; fi < featureMap.cols; fi++ )
+ if( featureMap_( 0, fi ) >= 0 )
+ {
+ fs << "{";
+ featIdx = fi / getFeatureSize();
+ componentIdx = fi % getFeatureSize();
+ features[featIdx].write( fs, componentIdx );
+ fs << "}";
+ }
+ fs << "]";
+}
+
+void CvHOGEvaluator::generateFeatures()
+{
+ int offset = winSize.width + 1;
+ Size blockStep;
+ int x, y, t, w, h;
+
+ for ( t = 8; t <= winSize.width / 2; t += 8 ) //t = size of a cell. blocksize = 4*cellSize
+ {
+ blockStep = Size( 4, 4 );
+ w = 2 * t; //width of a block
+ h = 2 * t; //height of a block
+ for ( x = 0; x <= winSize.width - w; x += blockStep.width )
+ {
+ for ( y = 0; y <= winSize.height - h; y += blockStep.height )
+ {
+ features.push_back( Feature( offset, x, y, t, t ) );
+ }
+ }
+ w = 2 * t;
+ h = 4 * t;
+ for ( x = 0; x <= winSize.width - w; x += blockStep.width )
+ {
+ for ( y = 0; y <= winSize.height - h; y += blockStep.height )
+ {
+ features.push_back( Feature( offset, x, y, t, 2 * t ) );
+ }
+ }
+ w = 4 * t;
+ h = 2 * t;
+ for ( x = 0; x <= winSize.width - w; x += blockStep.width )
+ {
+ for ( y = 0; y <= winSize.height - h; y += blockStep.height )
+ {
+ features.push_back( Feature( offset, x, y, 2 * t, t ) );
+ }
+ }
+ }
+
+ numFeatures = (int) features.size();
+}
+
+CvHOGEvaluator::Feature::Feature()
+{
+ for ( int i = 0; i < N_CELLS; i++ )
+ {
+ rect[i] = Rect( 0, 0, 0, 0 );
+ }
+}
+
+CvHOGEvaluator::Feature::Feature( int offset, int x, int y, int cellW, int cellH )
+{
+ rect[0] = Rect( x, y, cellW, cellH ); //cell0
+ rect[1] = Rect( x + cellW, y, cellW, cellH ); //cell1
+ rect[2] = Rect( x, y + cellH, cellW, cellH ); //cell2
+ rect[3] = Rect( x + cellW, y + cellH, cellW, cellH ); //cell3
+
+ for ( int i = 0; i < N_CELLS; i++ )
+ {
+ CV_SUM_OFFSETS( fastRect[i].p0, fastRect[i].p1, fastRect[i].p2, fastRect[i].p3, rect[i], offset );
+ }
+}
+
+void CvHOGEvaluator::Feature::write( FileStorage &fs ) const
+{
+ fs << CC_RECTS << "[";
+ for ( int i = 0; i < N_CELLS; i++ )
+ {
+ fs << "[:" << rect[i].x << rect[i].y << rect[i].width << rect[i].height << "]";
+ }
+ fs << "]";
+}
+
+//cell and bin idx writing
+//void CvHOGEvaluator::Feature::write(FileStorage &fs, int varIdx) const
+//{
+// int featComponent = varIdx % (N_CELLS * N_BINS);
+// int cellIdx = featComponent / N_BINS;
+// int binIdx = featComponent % N_BINS;
+//
+// fs << CC_RECTS << "[:" << rect[cellIdx].x << rect[cellIdx].y <<
+// rect[cellIdx].width << rect[cellIdx].height << binIdx << "]";
+//}
+
+//cell[0] and featComponent idx writing. By cell[0] it's possible to recover all block
+//All block is nessesary for block normalization
+void CvHOGEvaluator::Feature::write( FileStorage &fs, int featComponentIdx ) const
+{
+ fs << CC_RECT << "[:" << rect[0].x << rect[0].y << rect[0].width << rect[0].height << featComponentIdx << "]";
+}
+
+void CvHOGEvaluator::integralHistogram( const Mat &img, std::vector<Mat> &histogram, Mat &norm, int nbins ) const
+{
+ CV_Assert( img.type() == CV_8U || img.type() == CV_8UC3 );
+ int x, y, binIdx;
+
+ Size gradSize( img.size() );
+ Size histSize( histogram[0].size() );
+ Mat grad( gradSize, CV_32F );
+ Mat qangle( gradSize, CV_8U );
+
+ AutoBuffer<int> mapbuf( gradSize.width + gradSize.height + 4 );
+ int* xmap = (int*) mapbuf + 1;
+ int* ymap = xmap + gradSize.width + 2;
+
+ const int borderType = (int) BORDER_REPLICATE;
+
+ for ( x = -1; x < gradSize.width + 1; x++ )
+ xmap[x] = borderInterpolate( x, gradSize.width, borderType );
+ for ( y = -1; y < gradSize.height + 1; y++ )
+ ymap[y] = borderInterpolate( y, gradSize.height, borderType );
+
+ int width = gradSize.width;
+ AutoBuffer<float> _dbuf( width * 4 );
+ float* dbuf = _dbuf;
+ Mat Dx( 1, width, CV_32F, dbuf );
+ Mat Dy( 1, width, CV_32F, dbuf + width );
+ Mat Mag( 1, width, CV_32F, dbuf + width * 2 );
+ Mat Angle( 1, width, CV_32F, dbuf + width * 3 );
+
+ float angleScale = (float) ( nbins / CV_PI );
+
+ for ( y = 0; y < gradSize.height; y++ )
+ {
+ const uchar* currPtr = img.data + img.step * ymap[y];
+ const uchar* prevPtr = img.data + img.step * ymap[y - 1];
+ const uchar* nextPtr = img.data + img.step * ymap[y + 1];
+ float* gradPtr = (float*) grad.ptr( y );
+ uchar* qanglePtr = (uchar*) qangle.ptr( y );
+
+ for ( x = 0; x < width; x++ )
+ {
+ dbuf[x] = (float) ( currPtr[xmap[x + 1]] - currPtr[xmap[x - 1]] );
+ dbuf[width + x] = (float) ( nextPtr[xmap[x]] - prevPtr[xmap[x]] );
+ }
+ cartToPolar( Dx, Dy, Mag, Angle, false );
+ for ( x = 0; x < width; x++ )
+ {
+ float mag = dbuf[x + width * 2];
+ float angle = dbuf[x + width * 3];
+ angle = angle * angleScale - 0.5f;
+ int bidx = cvFloor( angle );
+ angle -= bidx;
+ if( bidx < 0 )
+ bidx += nbins;
+ else if( bidx >= nbins )
+ bidx -= nbins;
+
+ qanglePtr[x] = (uchar) bidx;
+ gradPtr[x] = mag;
+ }
+ }
+ integral( grad, norm, grad.depth() );
+
+ float* histBuf;
+ const float* magBuf;
+ const uchar* binsBuf;
+
+ int binsStep = (int) ( qangle.step / sizeof(uchar) );
+ int histStep = (int) ( histogram[0].step / sizeof(float) );
+ int magStep = (int) ( grad.step / sizeof(float) );
+ for ( binIdx = 0; binIdx < nbins; binIdx++ )
+ {
+ histBuf = (float*) histogram[binIdx].data;
+ magBuf = (const float*) grad.data;
+ binsBuf = (const uchar*) qangle.data;
+
+ memset( histBuf, 0, histSize.width * sizeof ( histBuf[0] ) );
+ histBuf += histStep + 1;
+ for ( y = 0; y < qangle.rows; y++ )
+ {
+ histBuf[-1] = 0.f;
+ float strSum = 0.f;
+ for ( x = 0; x < qangle.cols; x++ )
+ {
+ if( binsBuf[x] == binIdx )
+ strSum += magBuf[x];
+ histBuf[x] = histBuf[-histStep + x] + strSum;
+ }
+ histBuf += histStep;
+ binsBuf += binsStep;
+ magBuf += magStep;
+ }
+ }
+}
+
+CvLBPFeatureParams::CvLBPFeatureParams()
+{
+ maxCatCount = 256;
+ name = LBPF_NAME;
+}
+
+void CvLBPEvaluator::init( const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize )
+{
+ CV_Assert( _maxSampleCount > 0 );
+ sum.create( (int) _maxSampleCount, ( _winSize.width + 1 ) * ( _winSize.height + 1 ), CV_32SC1 );
+ CvFeatureEvaluator::init( _featureParams, _maxSampleCount, _winSize );
+}
+
+void CvLBPEvaluator::setImage( const Mat &img, uchar clsLabel, int idx )
+{
+ CV_DbgAssert( !sum.empty() );
+ CvFeatureEvaluator::setImage( img, clsLabel, idx );
+ Mat innSum( winSize.height + 1, winSize.width + 1, sum.type(), sum.ptr<int>( (int) idx ) );
+ integral( img, innSum );
+}
+
+void CvLBPEvaluator::writeFeatures( FileStorage &fs, const Mat& featureMap ) const
+{
+ _writeFeatures( features, fs, featureMap );
+}
+
+void CvLBPEvaluator::generateFeatures()
+{
+ int offset = winSize.width + 1;
+ for ( int x = 0; x < winSize.width; x++ )
+ for ( int y = 0; y < winSize.height; y++ )
+ for ( int w = 1; w <= winSize.width / 3; w++ )
+ for ( int h = 1; h <= winSize.height / 3; h++ )
+ if( ( x + 3 * w <= winSize.width ) && ( y + 3 * h <= winSize.height ) )
+ features.push_back( Feature( offset, x, y, w, h ) );
+ numFeatures = (int) features.size();
+}
+
+CvLBPEvaluator::Feature::Feature()
+{
+ rect = Rect( 0, 0, 0, 0 );
+}
+
+CvLBPEvaluator::Feature::Feature( int offset, int x, int y, int _blockWidth, int _blockHeight )
+{
+ Rect tr = rect = Rect( x, y, _blockWidth, _blockHeight );
+ CV_SUM_OFFSETS( p[0], p[1], p[4], p[5], tr, offset )
+ tr.x += 2 * rect.width;
+ CV_SUM_OFFSETS( p[2], p[3], p[6], p[7], tr, offset )
+ tr.y += 2 * rect.height;
+ CV_SUM_OFFSETS( p[10], p[11], p[14], p[15], tr, offset )
+ tr.x -= 2 * rect.width;
+ CV_SUM_OFFSETS( p[8], p[9], p[12], p[13], tr, offset )
+}
+
+void CvLBPEvaluator::Feature::write( FileStorage &fs ) const
+{
+ fs << CC_RECT << "[:" << rect.x << rect.y << rect.width << rect.height << "]";
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/onlineBoosting.cpp b/modules/tracking/src/onlineBoosting.cpp
new file mode 100644
index 000000000..b1b185168
--- /dev/null
+++ b/modules/tracking/src/onlineBoosting.cpp
@@ -0,0 +1,735 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include "opencv2/tracking/onlineBoosting.hpp"
+
+namespace cv
+{
+
+StrongClassifierDirectSelection::StrongClassifierDirectSelection( int numBaseClf, int numWeakClf, Size patchSz, const Rect& sampleROI,
+ bool useFeatureEx, int iterationInit )
+{
+ //StrongClassifier
+ numBaseClassifier = numBaseClf;
+ numAllWeakClassifier = numWeakClf + iterationInit;
+ iterInit = iterationInit;
+ numWeakClassifier = numWeakClf;
+
+ alpha.assign( numBaseClf, 0 );
+
+ patchSize = patchSz;
+ useFeatureExchange = useFeatureEx;
+
+ m_errorMask.resize( numAllWeakClassifier );
+ m_errors.resize( numAllWeakClassifier );
+ m_sumErrors.resize( numAllWeakClassifier );
+
+ ROI = sampleROI;
+ detector = new Detector( this );
+}
+
+void StrongClassifierDirectSelection::initBaseClassifier()
+{
+ baseClassifier = new BaseClassifier*[numBaseClassifier];
+ baseClassifier[0] = new BaseClassifier( numWeakClassifier, iterInit );
+
+ for ( int curBaseClassifier = 1; curBaseClassifier < numBaseClassifier; curBaseClassifier++ )
+ baseClassifier[curBaseClassifier] = new BaseClassifier( numWeakClassifier, iterInit, baseClassifier[0]->getReferenceWeakClassifier() );
+}
+
+StrongClassifierDirectSelection::~StrongClassifierDirectSelection()
+{
+ for ( int curBaseClassifier = 0; curBaseClassifier < numBaseClassifier; curBaseClassifier++ )
+ delete baseClassifier[curBaseClassifier];
+ delete[] baseClassifier;
+ alpha.clear();
+ delete detector;
+}
+
+Size StrongClassifierDirectSelection::getPatchSize() const
+{
+ return patchSize;
+}
+
+Rect StrongClassifierDirectSelection::getROI() const
+{
+ return ROI;
+}
+
+float StrongClassifierDirectSelection::classifySmooth( const std::vector<Mat>& images, const Rect& sampleROI, int& idx )
+{
+ ROI = sampleROI;
+ idx = 0;
+ float confidence = 0;
+ //detector->classify (image, patches);
+ detector->classifySmooth( images );
+
+ //move to best detection
+ if( detector->getNumDetections() <= 0 )
+ {
+ confidence = 0;
+ return confidence;
+ }
+ idx = detector->getPatchIdxOfBestDetection();
+ confidence = detector->getConfidenceOfBestDetection();
+
+ return confidence;
+}
+
+bool StrongClassifierDirectSelection::getUseFeatureExchange() const
+{
+ return useFeatureExchange;
+}
+
+int StrongClassifierDirectSelection::getReplacedClassifier() const
+{
+ return replacedClassifier;
+}
+
+int StrongClassifierDirectSelection::getSwappedClassifier() const
+{
+ return swappedClassifier;
+}
+
+bool StrongClassifierDirectSelection::update( const Mat& image, int target, float importance )
+{
+ m_errorMask.assign( numAllWeakClassifier, 0 );
+ m_errors.assign( numAllWeakClassifier, 0 );
+ m_sumErrors.assign( numAllWeakClassifier, 0 );
+
+ baseClassifier[0]->trainClassifier( image, target, importance, m_errorMask );
+ for ( int curBaseClassifier = 0; curBaseClassifier < numBaseClassifier; curBaseClassifier++ )
+ {
+ int selectedClassifier = baseClassifier[curBaseClassifier]->selectBestClassifier( m_errorMask, importance, m_errors );
+
+ if( m_errors[selectedClassifier] >= 0.5 )
+ alpha[curBaseClassifier] = 0;
+ else
+ alpha[curBaseClassifier] = logf( ( 1.0f - m_errors[selectedClassifier] ) / m_errors[selectedClassifier] );
+
+ if( m_errorMask[selectedClassifier] )
+ importance *= (float) sqrt( ( 1.0f - m_errors[selectedClassifier] ) / m_errors[selectedClassifier] );
+ else
+ importance *= (float) sqrt( m_errors[selectedClassifier] / ( 1.0f - m_errors[selectedClassifier] ) );
+
+ //weight limitation
+ //if (importance > 100) importance = 100;
+
+ //sum up errors
+ for ( int curWeakClassifier = 0; curWeakClassifier < numAllWeakClassifier; curWeakClassifier++ )
+ {
+ if( m_errors[curWeakClassifier] != FLT_MAX && m_sumErrors[curWeakClassifier] >= 0 )
+ m_sumErrors[curWeakClassifier] += m_errors[curWeakClassifier];
+ }
+
+ //mark feature as used
+ m_sumErrors[selectedClassifier] = -1;
+ m_errors[selectedClassifier] = FLT_MAX;
+ }
+
+ if( useFeatureExchange )
+ {
+ replacedClassifier = baseClassifier[0]->computeReplaceWeakestClassifier( m_sumErrors );
+ swappedClassifier = baseClassifier[0]->getIdxOfNewWeakClassifier();
+ }
+
+ return true;
+}
+
+void StrongClassifierDirectSelection::replaceWeakClassifier( int idx )
+{
+ if( useFeatureExchange && idx >= 0 )
+ {
+ baseClassifier[0]->replaceWeakClassifier( idx );
+ for ( int curBaseClassifier = 1; curBaseClassifier < numBaseClassifier; curBaseClassifier++ )
+ baseClassifier[curBaseClassifier]->replaceClassifierStatistic( baseClassifier[0]->getIdxOfNewWeakClassifier(), idx );
+ }
+}
+
+std::vector<int> StrongClassifierDirectSelection::getSelectedWeakClassifier()
+{
+ std::vector<int> selected;
+ int curBaseClassifier = 0;
+ for ( curBaseClassifier = 0; curBaseClassifier < numBaseClassifier; curBaseClassifier++ )
+ {
+ selected.push_back( baseClassifier[curBaseClassifier]->getSelectedClassifier() );
+ }
+ return selected;
+}
+
+float StrongClassifierDirectSelection::eval( const Mat& response )
+{
+ float value = 0.0f;
+ int curBaseClassifier = 0;
+
+ for ( curBaseClassifier = 0; curBaseClassifier < numBaseClassifier; curBaseClassifier++ )
+ value += baseClassifier[curBaseClassifier]->eval( response ) * alpha[curBaseClassifier];
+
+ return value;
+}
+
+int StrongClassifierDirectSelection::getNumBaseClassifier()
+{
+ return numBaseClassifier;
+}
+
+BaseClassifier::BaseClassifier( int numWeakClassifier, int iterationInit )
+{
+ this->m_numWeakClassifier = numWeakClassifier;
+ this->m_iterationInit = iterationInit;
+
+ weakClassifier = new WeakClassifierHaarFeature*[numWeakClassifier + iterationInit];
+ m_idxOfNewWeakClassifier = numWeakClassifier;
+
+ generateRandomClassifier();
+
+ m_referenceWeakClassifier = false;
+ m_selectedClassifier = 0;
+
+ m_wCorrect.assign( numWeakClassifier + iterationInit, 0 );
+
+ m_wWrong.assign( numWeakClassifier + iterationInit, 0 );
+
+ for ( int curWeakClassifier = 0; curWeakClassifier < numWeakClassifier + iterationInit; curWeakClassifier++ )
+ m_wWrong[curWeakClassifier] = m_wCorrect[curWeakClassifier] = 1;
+}
+
+BaseClassifier::BaseClassifier( int numWeakClassifier, int iterationInit, WeakClassifierHaarFeature** weakCls )
+{
+ m_numWeakClassifier = numWeakClassifier;
+ m_iterationInit = iterationInit;
+ weakClassifier = weakCls;
+ m_referenceWeakClassifier = true;
+ m_selectedClassifier = 0;
+ m_idxOfNewWeakClassifier = numWeakClassifier;
+
+ m_wCorrect.assign( numWeakClassifier + iterationInit, 0 );
+ m_wWrong.assign( numWeakClassifier + iterationInit, 0 );
+
+ for ( int curWeakClassifier = 0; curWeakClassifier < numWeakClassifier + iterationInit; curWeakClassifier++ )
+ m_wWrong[curWeakClassifier] = m_wCorrect[curWeakClassifier] = 1;
+}
+
+BaseClassifier::~BaseClassifier()
+{
+ if( !m_referenceWeakClassifier )
+ {
+ for ( int curWeakClassifier = 0; curWeakClassifier < m_numWeakClassifier + m_iterationInit; curWeakClassifier++ )
+ delete weakClassifier[curWeakClassifier];
+
+ delete[] weakClassifier;
+ }
+ m_wCorrect.clear();
+ m_wWrong.clear();
+}
+
+void BaseClassifier::generateRandomClassifier()
+{
+ for ( int curWeakClassifier = 0; curWeakClassifier < m_numWeakClassifier + m_iterationInit; curWeakClassifier++ )
+ {
+ weakClassifier[curWeakClassifier] = new WeakClassifierHaarFeature();
+ }
+}
+
+int BaseClassifier::eval( const Mat& image )
+{
+ return weakClassifier[m_selectedClassifier]->eval( image.at<float>( m_selectedClassifier ) );
+}
+
+int BaseClassifier::getSelectedClassifier() const
+{
+ return m_selectedClassifier;
+}
+
+void BaseClassifier::trainClassifier( const Mat& image, int target, float importance, std::vector<bool>& errorMask )
+{
+
+ //get poisson value
+ double A = 1;
+ int K = 0;
+ int K_max = 10;
+ while ( 1 )
+ {
+ double U_k = (double) rand() / RAND_MAX;
+ A *= U_k;
+ if( K > K_max || A < exp( -importance ) )
+ break;
+ K++;
+ }
+
+ for ( int curK = 0; curK <= K; curK++ )
+ {
+ for ( int curWeakClassifier = 0; curWeakClassifier < m_numWeakClassifier + m_iterationInit; curWeakClassifier++ )
+ {
+ errorMask[curWeakClassifier] = weakClassifier[curWeakClassifier]->update( image.at<float>( curWeakClassifier ), target );
+ }
+ }
+
+}
+
+float BaseClassifier::getError( int curWeakClassifier )
+{
+ if( curWeakClassifier == -1 )
+ curWeakClassifier = m_selectedClassifier;
+ return m_wWrong[curWeakClassifier] / ( m_wWrong[curWeakClassifier] + m_wCorrect[curWeakClassifier] );
+}
+
+int BaseClassifier::selectBestClassifier( std::vector<bool>& errorMask, float importance, std::vector<float> & errors )
+{
+ float minError = FLT_MAX;
+ int tmp_selectedClassifier = m_selectedClassifier;
+
+ for ( int curWeakClassifier = 0; curWeakClassifier < m_numWeakClassifier + m_iterationInit; curWeakClassifier++ )
+ {
+ if( errorMask[curWeakClassifier] )
+ {
+ m_wWrong[curWeakClassifier] += importance;
+ }
+ else
+ {
+ m_wCorrect[curWeakClassifier] += importance;
+ }
+
+ if( errors[curWeakClassifier] == FLT_MAX )
+ continue;
+
+ errors[curWeakClassifier] = m_wWrong[curWeakClassifier] / ( m_wWrong[curWeakClassifier] + m_wCorrect[curWeakClassifier] );
+
+ /*if(errors[curWeakClassifier] < 0.001 || !(errors[curWeakClassifier]>0.0))
+ {
+ errors[curWeakClassifier] = 0.001;
+ }
+
+ if(errors[curWeakClassifier] >= 1.0)
+ errors[curWeakClassifier] = 0.999;
+
+ assert (errors[curWeakClassifier] > 0.0);
+ assert (errors[curWeakClassifier] < 1.0);*/
+
+ if( curWeakClassifier < m_numWeakClassifier )
+ {
+ if( errors[curWeakClassifier] < minError )
+ {
+ minError = errors[curWeakClassifier];
+ tmp_selectedClassifier = curWeakClassifier;
+ }
+ }
+ }
+
+ m_selectedClassifier = tmp_selectedClassifier;
+ return m_selectedClassifier;
+}
+
+void BaseClassifier::getErrors( float* errors )
+{
+ for ( int curWeakClassifier = 0; curWeakClassifier < m_numWeakClassifier + m_iterationInit; curWeakClassifier++ )
+ {
+ if( errors[curWeakClassifier] == FLT_MAX )
+ continue;
+
+ errors[curWeakClassifier] = m_wWrong[curWeakClassifier] / ( m_wWrong[curWeakClassifier] + m_wCorrect[curWeakClassifier] );
+
+ CV_Assert( errors[curWeakClassifier] > 0 );
+ }
+}
+
+void BaseClassifier::replaceWeakClassifier( int index )
+{
+ delete weakClassifier[index];
+ weakClassifier[index] = weakClassifier[m_idxOfNewWeakClassifier];
+ m_wWrong[index] = m_wWrong[m_idxOfNewWeakClassifier];
+ m_wWrong[m_idxOfNewWeakClassifier] = 1;
+ m_wCorrect[index] = m_wCorrect[m_idxOfNewWeakClassifier];
+ m_wCorrect[m_idxOfNewWeakClassifier] = 1;
+
+ weakClassifier[m_idxOfNewWeakClassifier] = new WeakClassifierHaarFeature();
+}
+
+int BaseClassifier::computeReplaceWeakestClassifier( const std::vector<float> & errors )
+{
+ float maxError = 0.0f;
+ int index = -1;
+
+ //search the classifier with the largest error
+ for ( int curWeakClassifier = m_numWeakClassifier - 1; curWeakClassifier >= 0; curWeakClassifier-- )
+ {
+ if( errors[curWeakClassifier] > maxError )
+ {
+ maxError = errors[curWeakClassifier];
+ index = curWeakClassifier;
+ }
+ }
+
+ CV_Assert( index > -1 );
+ CV_Assert( index != m_selectedClassifier );
+
+ //replace
+ m_idxOfNewWeakClassifier++;
+ if( m_idxOfNewWeakClassifier == m_numWeakClassifier + m_iterationInit )
+ m_idxOfNewWeakClassifier = m_numWeakClassifier;
+
+ if( maxError > errors[m_idxOfNewWeakClassifier] )
+ {
+ return index;
+ }
+ else
+ return -1;
+
+}
+
+void BaseClassifier::replaceClassifierStatistic( int sourceIndex, int targetIndex )
+{
+ CV_Assert( targetIndex >= 0 );
+ CV_Assert( targetIndex != m_selectedClassifier );
+ CV_Assert( targetIndex < m_numWeakClassifier );
+
+ //replace
+ m_wWrong[targetIndex] = m_wWrong[sourceIndex];
+ m_wWrong[sourceIndex] = 1.0f;
+ m_wCorrect[targetIndex] = m_wCorrect[sourceIndex];
+ m_wCorrect[sourceIndex] = 1.0f;
+}
+
+EstimatedGaussDistribution::EstimatedGaussDistribution()
+{
+ m_mean = 0;
+ m_sigma = 1;
+ this->m_P_mean = 1000;
+ this->m_R_mean = 0.01f;
+ this->m_P_sigma = 1000;
+ this->m_R_sigma = 0.01f;
+}
+
+EstimatedGaussDistribution::EstimatedGaussDistribution( float P_mean, float R_mean, float P_sigma, float R_sigma )
+{
+ m_mean = 0;
+ m_sigma = 1;
+ this->m_P_mean = P_mean;
+ this->m_R_mean = R_mean;
+ this->m_P_sigma = P_sigma;
+ this->m_R_sigma = R_sigma;
+}
+
+EstimatedGaussDistribution::~EstimatedGaussDistribution()
+{
+}
+
+void EstimatedGaussDistribution::update( float value )
+{
+//update distribution (mean and sigma) using a kalman filter for each
+
+ float K;
+ float minFactor = 0.001f;
+
+//mean
+
+ K = m_P_mean / ( m_P_mean + m_R_mean );
+ if( K < minFactor )
+ K = minFactor;
+
+ m_mean = K * value + ( 1.0f - K ) * m_mean;
+ m_P_mean = m_P_mean * m_R_mean / ( m_P_mean + m_R_mean );
+
+ K = m_P_sigma / ( m_P_sigma + m_R_sigma );
+ if( K < minFactor )
+ K = minFactor;
+
+ float tmp_sigma = K * ( m_mean - value ) * ( m_mean - value ) + ( 1.0f - K ) * m_sigma * m_sigma;
+ m_P_sigma = m_P_sigma * m_R_mean / ( m_P_sigma + m_R_sigma );
+
+ m_sigma = static_cast<float>( sqrt( tmp_sigma ) );
+ if( m_sigma <= 1.0f )
+ m_sigma = 1.0f;
+
+}
+
+void EstimatedGaussDistribution::setValues( float mean, float sigma )
+{
+ this->m_mean = mean;
+ this->m_sigma = sigma;
+}
+
+float EstimatedGaussDistribution::getMean()
+{
+ return m_mean;
+}
+
+float EstimatedGaussDistribution::getSigma()
+{
+ return m_sigma;
+}
+
+WeakClassifierHaarFeature::WeakClassifierHaarFeature()
+{
+ sigma = 1;
+ mean = 0;
+
+ EstimatedGaussDistribution* m_posSamples = new EstimatedGaussDistribution();
+ EstimatedGaussDistribution* m_negSamples = new EstimatedGaussDistribution();
+ generateRandomClassifier( m_posSamples, m_negSamples );
+
+ getInitialDistribution( (EstimatedGaussDistribution*) m_classifier->getDistribution( -1 ) );
+ getInitialDistribution( (EstimatedGaussDistribution*) m_classifier->getDistribution( 1 ) );
+}
+
+WeakClassifierHaarFeature::~WeakClassifierHaarFeature()
+{
+ delete m_classifier;
+}
+
+void WeakClassifierHaarFeature::getInitialDistribution( EstimatedGaussDistribution* distribution )
+{
+ distribution->setValues( mean, sigma );
+}
+
+void WeakClassifierHaarFeature::generateRandomClassifier( EstimatedGaussDistribution* m_posSamples, EstimatedGaussDistribution* m_negSamples )
+{
+ m_classifier = new ClassifierThreshold( m_posSamples, m_negSamples );
+}
+
+bool WeakClassifierHaarFeature::update( float value, int target )
+{
+ m_classifier->update( value, target );
+ return ( m_classifier->eval( value ) != target );
+}
+
+int WeakClassifierHaarFeature::eval( float value )
+{
+ return m_classifier->eval( value );
+}
+
+Detector::Detector( StrongClassifierDirectSelection* classifier ) :
+ m_sizeDetections( 0 )
+{
+ this->m_classifier = classifier;
+
+ m_sizeConfidences = 0;
+ m_maxConfidence = -FLT_MAX;
+ m_numDetections = 0;
+ m_idxBestDetection = -1;
+}
+
+Detector::~Detector()
+{
+}
+
+void Detector::prepareConfidencesMemory( int numPatches )
+{
+ if( numPatches <= m_sizeConfidences )
+ return;
+
+ m_sizeConfidences = numPatches;
+ m_confidences.resize( numPatches );
+}
+
+void Detector::prepareDetectionsMemory( int numDetections )
+{
+ if( numDetections <= m_sizeDetections )
+ return;
+
+ m_sizeDetections = numDetections;
+ m_idxDetections.resize( numDetections );
+}
+
+void Detector::classifySmooth( const std::vector<Mat>& images, float minMargin )
+{
+ int numPatches = images.size();
+
+ prepareConfidencesMemory( numPatches );
+
+ m_numDetections = 0;
+ m_idxBestDetection = -1;
+ m_maxConfidence = -FLT_MAX;
+
+ //compute grid
+ //TODO 0.99 overlap from params
+ Size patchSz = m_classifier->getPatchSize();
+ int stepCol = (int) floor( ( 1.0f - 0.99f ) * (float) patchSz.width + 0.5f );
+ int stepRow = (int) floor( ( 1.0f - 0.99f ) * (float) patchSz.height + 0.5f );
+ if( stepCol <= 0 )
+ stepCol = 1;
+ if( stepRow <= 0 )
+ stepRow = 1;
+
+ Size patchGrid;
+ Rect ROI = m_classifier->getROI();
+ patchGrid.height = ( (int) ( (float) ( ROI.height - patchSz.height ) / stepRow ) + 1 );
+ patchGrid.width = ( (int) ( (float) ( ROI.width - patchSz.width ) / stepCol ) + 1 );
+
+ if( ( patchGrid.width != m_confMatrix.cols ) || ( patchGrid.height != m_confMatrix.rows ) )
+ {
+ m_confMatrix.create( patchGrid.height, patchGrid.width );
+ m_confMatrixSmooth.create( patchGrid.height, patchGrid.width );
+ m_confImageDisplay.create( patchGrid.height, patchGrid.width );
+ }
+
+ int curPatch = 0;
+ // Eval and filter
+ for ( int row = 0; row < patchGrid.height; row++ )
+ {
+ for ( int col = 0; col < patchGrid.width; col++ )
+ {
+ m_confidences[curPatch] = m_classifier->eval( images[curPatch] );
+
+ // fill matrix
+ m_confMatrix( row, col ) = m_confidences[curPatch];
+ curPatch++;
+ }
+ }
+
+ // Filter
+ //cv::GaussianBlur(m_confMatrix,m_confMatrixSmooth,cv::Size(3,3),0.8);
+ cv::GaussianBlur( m_confMatrix, m_confMatrixSmooth, cv::Size( 3, 3 ), 0 );
+
+ // Make display friendly
+ double min_val, max_val;
+ cv::minMaxLoc( m_confMatrixSmooth, &min_val, &max_val );
+ for ( int y = 0; y < m_confImageDisplay.rows; y++ )
+ {
+ unsigned char* pConfImg = m_confImageDisplay[y];
+ const float* pConfData = m_confMatrixSmooth[y];
+ for ( int x = 0; x < m_confImageDisplay.cols; x++, pConfImg++, pConfData++ )
+ {
+ *pConfImg = static_cast<unsigned char>( 255.0 * ( *pConfData - min_val ) / ( max_val - min_val ) );
+ }
+ }
+
+ // Get best detection
+ curPatch = 0;
+ for ( int row = 0; row < patchGrid.height; row++ )
+ {
+ for ( int col = 0; col < patchGrid.width; col++ )
+ {
+ // fill matrix
+ m_confidences[curPatch] = m_confMatrixSmooth( row, col );
+
+ if( m_confidences[curPatch] > m_maxConfidence )
+ {
+ m_maxConfidence = m_confidences[curPatch];
+ m_idxBestDetection = curPatch;
+ }
+ if( m_confidences[curPatch] > minMargin )
+ {
+ m_numDetections++;
+ }
+ curPatch++;
+ }
+ }
+
+ prepareDetectionsMemory( m_numDetections );
+ int curDetection = -1;
+ for ( int currentPatch = 0; currentPatch < numPatches; currentPatch++ )
+ {
+ if( m_confidences[currentPatch] > minMargin )
+ m_idxDetections[++curDetection] = currentPatch;
+ }
+}
+
+int Detector::getNumDetections()
+{
+ return m_numDetections;
+}
+
+float Detector::getConfidence( int patchIdx )
+{
+ return m_confidences[patchIdx];
+}
+
+float Detector::getConfidenceOfDetection( int detectionIdx )
+{
+ return m_confidences[getPatchIdxOfDetection( detectionIdx )];
+}
+
+int Detector::getPatchIdxOfBestDetection()
+{
+ return m_idxBestDetection;
+}
+
+int Detector::getPatchIdxOfDetection( int detectionIdx )
+{
+ return m_idxDetections[detectionIdx];
+}
+
+ClassifierThreshold::ClassifierThreshold( EstimatedGaussDistribution* posSamples, EstimatedGaussDistribution* negSamples )
+{
+ m_posSamples = posSamples;
+ m_negSamples = negSamples;
+ m_threshold = 0.0f;
+ m_parity = 0;
+}
+
+ClassifierThreshold::~ClassifierThreshold()
+{
+ if( m_posSamples != NULL )
+ delete m_posSamples;
+ if( m_negSamples != NULL )
+ delete m_negSamples;
+}
+
+void*
+ClassifierThreshold::getDistribution( int target )
+{
+ if( target == 1 )
+ return m_posSamples;
+ else
+ return m_negSamples;
+}
+
+void ClassifierThreshold::update( float value, int target )
+{
+ //update distribution
+ if( target == 1 )
+ m_posSamples->update( value );
+ else
+ m_negSamples->update( value );
+
+ //adapt threshold and parity
+ m_threshold = ( m_posSamples->getMean() + m_negSamples->getMean() ) / 2.0f;
+ m_parity = ( m_posSamples->getMean() > m_negSamples->getMean() ) ? 1 : -1;
+}
+
+int ClassifierThreshold::eval( float value )
+{
+ return ( ( ( m_parity * ( value - m_threshold ) ) > 0 ) ? 1 : -1 );
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/onlineMIL.cpp b/modules/tracking/src/onlineMIL.cpp
new file mode 100644
index 000000000..9b8532b25
--- /dev/null
+++ b/modules/tracking/src/onlineMIL.cpp
@@ -0,0 +1,379 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include "opencv2/tracking/onlineMIL.hpp"
+
+template<class T> class SortableElementRev
+{
+ public:
+ T _val;
+ int _ind;
+ SortableElementRev() :
+ _ind( 0 )
+ {
+ }
+ SortableElementRev( T val, int ind )
+ {
+ _val = val;
+ _ind = ind;
+ }
+ bool operator<( SortableElementRev<T> &b )
+ {
+ return ( _val < b._val );
+ }
+ ;
+};
+
+static bool CompareSortableElementRev( const SortableElementRev<float>& i, const SortableElementRev<float>& j )
+{
+ return i._val < j._val;
+}
+
+template<class T> void sort_order_des( std::vector<T> &v, std::vector<int> &order )
+{
+ uint n = (uint) v.size();
+ std::vector<SortableElementRev<T> > v2;
+ v2.resize( n );
+ order.clear();
+ order.resize( n );
+ for ( uint i = 0; i < n; i++ )
+ {
+ v2[i]._ind = i;
+ v2[i]._val = v[i];
+ }
+ //std::sort( v2.begin(), v2.end() );
+ std::sort( v2.begin(), v2.end(), CompareSortableElementRev );
+ for ( uint i = 0; i < n; i++ )
+ {
+ order[i] = v2[i]._ind;
+ v[i] = v2[i]._val;
+ }
+}
+;
+
+namespace cv
+{
+
+//implementations for strong classifier
+
+ClfMilBoost::Params::Params()
+{
+ _numSel = 50;
+ _numFeat = 250;
+ _lRate = 0.85;
+}
+
+ClfMilBoost::ClfMilBoost()
+{
+ _myParams = ClfMilBoost::Params();
+ _numsamples = 0;
+}
+
+ClfMilBoost::~ClfMilBoost()
+{
+ _selectors.clear();
+ for ( size_t i = 0; i < _weakclf.size(); i++ )
+ delete _weakclf.at( i );
+}
+
+void ClfMilBoost::init( const ClfMilBoost::Params ¶meters )
+{
+ _myParams = parameters;
+ _numsamples = 0;
+
+ //_ftrs = Ftr::generate( _myParams->_ftrParams, _myParams->_numFeat );
+ // if( params->_storeFtrHistory )
+ // Ftr::toViz( _ftrs, "haarftrs" );
+ _weakclf.resize( _myParams._numFeat );
+ for ( int k = 0; k < _myParams._numFeat; k++ )
+ {
+ _weakclf[k] = new ClfOnlineStump( k );
+ _weakclf[k]->_lRate = _myParams._lRate;
+
+ }
+ _counter = 0;
+}
+
+void ClfMilBoost::update( const Mat& posx, const Mat& negx )
+{
+ int numneg = negx.rows;
+ int numpos = posx.rows;
+
+ // compute ftrs
+ //if( !posx.ftrsComputed() )
+ // Ftr::compute( posx, _ftrs );
+ //if( !negx.ftrsComputed() )
+ // Ftr::compute( negx, _ftrs );
+
+ // initialize H
+ static std::vector<float> Hpos, Hneg;
+ Hpos.clear();
+ Hneg.clear();
+ Hpos.resize( posx.rows, 0.0f ), Hneg.resize( negx.rows, 0.0f );
+
+ _selectors.clear();
+ std::vector<float> posw( posx.rows ), negw( negx.rows );
+ std::vector<std::vector<float> > pospred( _weakclf.size() ), negpred( _weakclf.size() );
+
+ // train all weak classifiers without weights
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+ for ( int m = 0; m < _myParams._numFeat; m++ )
+ {
+ _weakclf[m]->update( posx, negx );
+ pospred[m] = _weakclf[m]->classifySetF( posx );
+ negpred[m] = _weakclf[m]->classifySetF( negx );
+ }
+
+ // pick the best features
+ for ( int s = 0; s < _myParams._numSel; s++ )
+ {
+
+ // compute errors/likl for all weak clfs
+ std::vector<float> poslikl( _weakclf.size(), 1.0f ), neglikl( _weakclf.size() ), likl( _weakclf.size() );
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+ for ( int w = 0; w < (int) _weakclf.size(); w++ )
+ {
+ float lll = 1.0f;
+ for ( int j = 0; j < numpos; j++ )
+ lll *= ( 1 - sigmoid( Hpos[j] + pospred[w][j] ) );
+ poslikl[w] = (float) -log( 1 - lll + 1e-5 );
+
+ lll = 0.0f;
+ for ( int j = 0; j < numneg; j++ )
+ lll += (float) -log( 1e-5f + 1 - sigmoid( Hneg[j] + negpred[w][j] ) );
+ neglikl[w] = lll;
+
+ likl[w] = poslikl[w] / numpos + neglikl[w] / numneg;
+ }
+
+ // pick best weak clf
+ std::vector<int> order;
+ sort_order_des( likl, order );
+
+ // find best weakclf that isn't already included
+ for ( uint k = 0; k < order.size(); k++ )
+ if( std::count( _selectors.begin(), _selectors.end(), order[k] ) == 0 )
+ {
+ _selectors.push_back( order[k] );
+ break;
+ }
+
+ // update H = H + h_m
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+ for ( int k = 0; k < posx.rows; k++ )
+ Hpos[k] += pospred[_selectors[s]][k];
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+ for ( int k = 0; k < negx.rows; k++ )
+ Hneg[k] += negpred[_selectors[s]][k];
+
+ }
+
+ //if( _myParams->_storeFtrHistory )
+ //for ( uint j = 0; j < _selectors.size(); j++ )
+ // _ftrHist( _selectors[j], _counter ) = 1.0f / ( j + 1 );
+
+ _counter++;
+ /* */
+ return;
+}
+
+std::vector<float> ClfMilBoost::classify( const Mat& x, bool logR )
+{
+ int numsamples = x.rows;
+ std::vector<float> res( numsamples );
+ std::vector<float> tr;
+
+ for ( uint w = 0; w < _selectors.size(); w++ )
+ {
+ tr = _weakclf[_selectors[w]]->classifySetF( x );
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+ for ( int j = 0; j < numsamples; j++ )
+ {
+ res[j] += tr[j];
+ }
+ }
+
+ // return probabilities or log odds ratio
+ if( !logR )
+ {
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+ for ( int j = 0; j < (int) res.size(); j++ )
+ {
+ res[j] = sigmoid( res[j] );
+ }
+ }
+
+ return res;
+}
+
+//implementations for weak classifier
+
+ClfOnlineStump::ClfOnlineStump()
+{
+ _trained = false;
+ _ind = -1;
+ init();
+}
+
+ClfOnlineStump::ClfOnlineStump( int ind )
+{
+ _trained = false;
+ _ind = ind;
+ init();
+}
+void ClfOnlineStump::init()
+{
+ _mu0 = 0;
+ _mu1 = 0;
+ _sig0 = 1;
+ _sig1 = 1;
+ _lRate = 0.85f;
+ _trained = false;
+}
+
+void ClfOnlineStump::update( const Mat& posx, const Mat& negx, const Mat_<float>& /*posw*/, const Mat_<float>& /*negw*/)
+{
+ //std::cout << " ClfOnlineStump::update" << _ind << std::endl;
+ float posmu = 0.0, negmu = 0.0;
+ if( posx.cols > 0 )
+ posmu = float( mean( posx.col( _ind ) )[0] );
+ if( negx.cols > 0 )
+ negmu = float( mean( negx.col( _ind ) )[0] );
+
+ if( _trained )
+ {
+ if( posx.cols > 0 )
+ {
+ _mu1 = ( _lRate * _mu1 + ( 1 - _lRate ) * posmu );
+ cv::Mat diff = posx.col( _ind ) - _mu1;
+ _sig1 = _lRate * _sig1 + ( 1 - _lRate ) * float( mean( diff.mul( diff ) )[0] );
+ }
+ if( negx.cols > 0 )
+ {
+ _mu0 = ( _lRate * _mu0 + ( 1 - _lRate ) * negmu );
+ cv::Mat diff = negx.col( _ind ) - _mu0;
+ _sig0 = _lRate * _sig0 + ( 1 - _lRate ) * float( mean( diff.mul( diff ) )[0] );
+ }
+
+ _q = ( _mu1 - _mu0 ) / 2;
+ _s = sign( _mu1 - _mu0 );
+ _log_n0 = std::log( float( 1.0f / pow( _sig0, 0.5f ) ) );
+ _log_n1 = std::log( float( 1.0f / pow( _sig1, 0.5f ) ) );
+ //_e1 = -1.0f/(2.0f*_sig1+1e-99f);
+ //_e0 = -1.0f/(2.0f*_sig0+1e-99f);
+ _e1 = -1.0f / ( 2.0f * _sig1 + std::numeric_limits<float>::min() );
+ _e0 = -1.0f / ( 2.0f * _sig0 + std::numeric_limits<float>::min() );
+
+ }
+ else
+ {
+ _trained = true;
+ if( posx.cols > 0 )
+ {
+ _mu1 = posmu;
+ cv::Scalar scal_mean, scal_std_dev;
+ cv::meanStdDev( posx.col( _ind ), scal_mean, scal_std_dev );
+ _sig1 = float( scal_std_dev[0] ) * float( scal_std_dev[0] ) + 1e-9f;
+ }
+
+ if( negx.cols > 0 )
+ {
+ _mu0 = negmu;
+ cv::Scalar scal_mean, scal_std_dev;
+ cv::meanStdDev( negx.col( _ind ), scal_mean, scal_std_dev );
+ _sig0 = float( scal_std_dev[0] ) * float( scal_std_dev[0] ) + 1e-9f;
+ }
+
+ _q = ( _mu1 - _mu0 ) / 2;
+ _s = sign( _mu1 - _mu0 );
+ _log_n0 = std::log( float( 1.0f / pow( _sig0, 0.5f ) ) );
+ _log_n1 = std::log( float( 1.0f / pow( _sig1, 0.5f ) ) );
+ //_e1 = -1.0f/(2.0f*_sig1+1e-99f);
+ //_e0 = -1.0f/(2.0f*_sig0+1e-99f);
+ _e1 = -1.0f / ( 2.0f * _sig1 + std::numeric_limits<float>::min() );
+ _e0 = -1.0f / ( 2.0f * _sig0 + std::numeric_limits<float>::min() );
+ }
+}
+
+bool ClfOnlineStump::classify( const Mat& x, int i )
+{
+ float xx = x.at<float>( i, _ind );
+ double log_p0 = ( xx - _mu0 ) * ( xx - _mu0 ) * _e0 + _log_n0;
+ double log_p1 = ( xx - _mu1 ) * ( xx - _mu1 ) * _e1 + _log_n1;
+ return log_p1 > log_p0;
+}
+
+float ClfOnlineStump::classifyF( const Mat& x, int i )
+{
+ float xx = x.at<float>( i, _ind );
+ double log_p0 = ( xx - _mu0 ) * ( xx - _mu0 ) * _e0 + _log_n0;
+ double log_p1 = ( xx - _mu1 ) * ( xx - _mu1 ) * _e1 + _log_n1;
+ return float( log_p1 - log_p0 );
+}
+
+inline std::vector<float> ClfOnlineStump::classifySetF( const Mat& x )
+{
+ std::vector<float> res( x.rows );
+
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+ for ( int k = 0; k < (int) res.size(); k++ )
+ {
+ res[k] = classifyF( x, k );
+ }
+ return res;
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/precomp.hpp b/modules/tracking/src/precomp.hpp
new file mode 100644
index 000000000..876306f0d
--- /dev/null
+++ b/modules/tracking/src/precomp.hpp
@@ -0,0 +1,49 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/tracking.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/private.hpp"
+
+#endif
diff --git a/modules/tracking/src/tracker.cpp b/modules/tracking/src/tracker.cpp
new file mode 100644
index 000000000..b2b690db5
--- /dev/null
+++ b/modules/tracking/src/tracker.cpp
@@ -0,0 +1,107 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/*
+ * Tracker
+ */
+
+Tracker::~Tracker()
+{
+}
+
+bool Tracker::init( const Mat& image, const Rect& boundingBox )
+{
+
+ if( isInit )
+ {
+ return false;
+ }
+
+ if( image.empty() )
+ return false;
+
+ sampler = Ptr<TrackerSampler>( new TrackerSampler() );
+ featureSet = Ptr<TrackerFeatureSet>( new TrackerFeatureSet() );
+ model = Ptr<TrackerModel>();
+
+ bool initTracker = initImpl( image, boundingBox );
+
+ //check if the model component is initialized
+ if( model == 0 )
+ {
+ CV_Error( -1, "The model are not initialized" );
+ return false;
+ }
+
+ if( initTracker )
+ {
+ isInit = true;
+ }
+
+ return initTracker;
+}
+
+bool Tracker::update( const Mat& image, Rect& boundingBox )
+{
+
+ if( !isInit )
+ {
+ return false;
+ }
+
+ if( image.empty() )
+ return false;
+
+ return updateImpl( image, boundingBox );
+}
+
+Ptr<Tracker> Tracker::create( const String& trackerType )
+{
+
+ return Algorithm::create<Tracker>( "TRACKER." + trackerType );
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/trackerBoosting.cpp b/modules/tracking/src/trackerBoosting.cpp
new file mode 100644
index 000000000..5a158d0ee
--- /dev/null
+++ b/modules/tracking/src/trackerBoosting.cpp
@@ -0,0 +1,308 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include "trackerBoostingModel.hpp"
+
+namespace cv
+{
+
+/*
+ * TrackerBoosting
+ */
+
+/*
+ * Parameters
+ */
+TrackerBoosting::Params::Params()
+{
+ numClassifiers = 100;
+ samplerOverlap = 0.99f;
+ samplerSearchFactor = 2;
+ iterationInit = 50;
+ featureSetNumFeatures = ( numClassifiers * 10 ) + iterationInit;
+}
+
+void TrackerBoosting::Params::read( const cv::FileNode& fn )
+{
+ numClassifiers = fn["numClassifiers"];
+ samplerOverlap = fn["overlap"];
+ samplerSearchFactor = fn["samplerSearchFactor"];
+ iterationInit = fn["iterationInit"];
+ samplerSearchFactor = fn["searchFactor"];
+}
+
+void TrackerBoosting::Params::write( cv::FileStorage& fs ) const
+{
+ fs << "numClassifiers" << numClassifiers;
+ fs << "overlap" << samplerOverlap;
+ fs << "searchFactor" << samplerSearchFactor;
+ fs << "iterationInit" << iterationInit;
+ fs << "samplerSearchFactor" << samplerSearchFactor;
+}
+
+/*
+ * Constructor
+ */
+TrackerBoosting::TrackerBoosting( const TrackerBoosting::Params ¶meters ) :
+ params( parameters )
+{
+ isInit = false;
+}
+
+/*
+ * Destructor
+ */
+TrackerBoosting::~TrackerBoosting()
+{
+
+}
+
+void TrackerBoosting::read( const cv::FileNode& fn )
+{
+ params.read( fn );
+}
+
+void TrackerBoosting::write( cv::FileStorage& fs ) const
+{
+ params.write( fs );
+}
+
+bool TrackerBoosting::initImpl( const Mat& image, const Rect& boundingBox )
+{
+ //sampling
+ Mat_<int> intImage;
+ Mat_<double> intSqImage;
+ Mat image_;
+ cvtColor( image, image_, CV_RGB2GRAY );
+ integral( image_, intImage, intSqImage, CV_32S );
+ TrackerSamplerCS::Params CSparameters;
+ CSparameters.overlap = params.samplerOverlap;
+ CSparameters.searchFactor = params.samplerSearchFactor;
+
+ Ptr<TrackerSamplerAlgorithm> CSSampler = Ptr<TrackerSamplerCS>( new TrackerSamplerCS( CSparameters ) );
+
+ if( !sampler->addTrackerSamplerAlgorithm( CSSampler ) )
+ return false;
+
+ CSSampler.staticCast<TrackerSamplerCS>()->setMode( TrackerSamplerCS::MODE_POSITIVE );
+ sampler->sampling( intImage, boundingBox );
+ const std::vector<Mat> posSamples = sampler->getSamples();
+
+ CSSampler.staticCast<TrackerSamplerCS>()->setMode( TrackerSamplerCS::MODE_NEGATIVE );
+ sampler->sampling( intImage, boundingBox );
+ const std::vector<Mat> negSamples = sampler->getSamples();
+
+ if( posSamples.empty() || negSamples.empty() )
+ return false;
+
+ Rect ROI = CSSampler.staticCast<TrackerSamplerCS>()->getROI();
+
+ //compute HAAR features
+ TrackerFeatureHAAR::Params HAARparameters;
+ HAARparameters.numFeatures = params.featureSetNumFeatures;
+ HAARparameters.isIntegral = true;
+ HAARparameters.rectSize = Size( boundingBox.width, boundingBox.height );
+ Ptr<TrackerFeature> trackerFeature = Ptr<TrackerFeatureHAAR>( new TrackerFeatureHAAR( HAARparameters ) );
+ if( !featureSet->addTrackerFeature( trackerFeature ) )
+ return false;
+
+ featureSet->extraction( posSamples );
+ const std::vector<Mat> posResponse = featureSet->getResponses();
+ featureSet->extraction( negSamples );
+ const std::vector<Mat> negResponse = featureSet->getResponses();
+
+ //Model
+ model = Ptr<TrackerBoostingModel>( new TrackerBoostingModel( boundingBox ) );
+ Ptr<TrackerStateEstimatorAdaBoosting> stateEstimator = Ptr<TrackerStateEstimatorAdaBoosting>(
+ new TrackerStateEstimatorAdaBoosting( params.numClassifiers, params.iterationInit, params.featureSetNumFeatures,
+ Size( boundingBox.width, boundingBox.height ), ROI ) );
+ model->setTrackerStateEstimator( stateEstimator );
+
+ //Run model estimation and update for iterationInit iterations
+ for ( int i = 0; i < params.iterationInit; i++ )
+ {
+ //compute temp features
+ TrackerFeatureHAAR::Params HAARparameters2;
+ HAARparameters2.numFeatures = ( posSamples.size() + negSamples.size() );
+ HAARparameters2.isIntegral = true;
+ HAARparameters2.rectSize = Size( boundingBox.width, boundingBox.height );
+ Ptr<TrackerFeatureHAAR> trackerFeature2 = Ptr<TrackerFeatureHAAR>( new TrackerFeatureHAAR( HAARparameters2 ) );
+
+ model.staticCast<TrackerBoostingModel>()->setMode( TrackerBoostingModel::MODE_NEGATIVE, negSamples );
+ model->modelEstimation( negResponse );
+ model.staticCast<TrackerBoostingModel>()->setMode( TrackerBoostingModel::MODE_POSITIVE, posSamples );
+ model->modelEstimation( posResponse );
+ model->modelUpdate();
+
+ //get replaced classifier and change the features
+ std::vector<int> replacedClassifier = stateEstimator->computeReplacedClassifier();
+ std::vector<int> swappedClassified = stateEstimator->computeSwappedClassifier();
+ for ( size_t j = 0; j < replacedClassifier.size(); j++ )
+ {
+ if( replacedClassifier[j] != -1 && swappedClassified[j] != -1 )
+ {
+ trackerFeature.staticCast<TrackerFeatureHAAR>()->swapFeature( replacedClassifier[j], swappedClassified[j] );
+ trackerFeature.staticCast<TrackerFeatureHAAR>()->swapFeature( swappedClassified[j], trackerFeature2->getFeatureAt( j ) );
+ }
+ }
+ }
+
+ return true;
+}
+
+bool TrackerBoosting::updateImpl( const Mat& image, Rect& boundingBox )
+{
+ Mat_<int> intImage;
+ Mat_<double> intSqImage;
+ Mat image_;
+ cvtColor( image, image_, CV_RGB2GRAY );
+ integral( image_, intImage, intSqImage, CV_32S );
+ //get the last location [AAM] X(k-1)
+ Ptr<TrackerTargetState> lastLocation = model->getLastTargetState();
+ Rect lastBoundingBox( lastLocation->getTargetPosition().x, lastLocation->getTargetPosition().y, lastLocation->getTargetWidth(),
+ lastLocation->getTargetHeight() );
+
+ //sampling new frame based on last location
+ ( sampler->getSamplers().at( 0 ).second ).staticCast<TrackerSamplerCS>()->setMode( TrackerSamplerCS::MODE_CLASSIFY );
+ sampler->sampling( intImage, lastBoundingBox );
+ const std::vector<Mat> detectSamples = sampler->getSamples();
+ Rect ROI = ( sampler->getSamplers().at( 0 ).second ).staticCast<TrackerSamplerCS>()->getROI();
+
+ if( detectSamples.empty() )
+ return false;
+
+ /*//TODO debug samples
+ Mat f;
+ image.copyTo( f );
+
+ for ( size_t i = 0; i < detectSamples.size(); i = i + 10 )
+ {
+ Size sz;
+ Point off;
+ detectSamples.at( i ).locateROI( sz, off );
+ rectangle( f, Rect( off.x, off.y, detectSamples.at( i ).cols, detectSamples.at( i ).rows ), Scalar( 255, 0, 0 ), 1 );
+ }*/
+
+ std::vector<Mat> responses;
+ Mat response;
+
+ std::vector<int> classifiers = model->getTrackerStateEstimator().staticCast<TrackerStateEstimatorAdaBoosting>()->computeSelectedWeakClassifier();
+ Ptr<TrackerFeatureHAAR> extractor = featureSet->getTrackerFeature()[0].second.staticCast<TrackerFeatureHAAR>();
+ extractor->extractSelected( classifiers, detectSamples, response );
+ responses.push_back( response );
+
+ //predict new location
+ ConfidenceMap cmap;
+ model.staticCast<TrackerBoostingModel>()->setMode( TrackerBoostingModel::MODE_CLASSIFY, detectSamples );
+ model.staticCast<TrackerBoostingModel>()->responseToConfidenceMap( responses, cmap );
+ model->getTrackerStateEstimator().staticCast<TrackerStateEstimatorAdaBoosting>()->setCurrentConfidenceMap( cmap );
+ model->getTrackerStateEstimator().staticCast<TrackerStateEstimatorAdaBoosting>()->setSampleROI( ROI );
+
+ if( !model->runStateEstimator() )
+ {
+ return false;
+ }
+
+ Ptr<TrackerTargetState> currentState = model->getLastTargetState();
+ boundingBox = Rect( currentState->getTargetPosition().x, currentState->getTargetPosition().y, currentState->getTargetWidth(),
+ currentState->getTargetHeight() );
+
+ /*//TODO debug
+ rectangle( f, lastBoundingBox, Scalar( 0, 255, 0 ), 1 );
+ rectangle( f, boundingBox, Scalar( 0, 0, 255 ), 1 );
+ imshow( "f", f );
+ //waitKey( 0 );*/
+
+ //sampling new frame based on new location
+ //Positive sampling
+ ( sampler->getSamplers().at( 0 ).second ).staticCast<TrackerSamplerCS>()->setMode( TrackerSamplerCS::MODE_POSITIVE );
+ sampler->sampling( intImage, boundingBox );
+ const std::vector<Mat> posSamples = sampler->getSamples();
+
+ //Negative sampling
+ ( sampler->getSamplers().at( 0 ).second ).staticCast<TrackerSamplerCS>()->setMode( TrackerSamplerCS::MODE_NEGATIVE );
+ sampler->sampling( intImage, boundingBox );
+ const std::vector<Mat> negSamples = sampler->getSamples();
+
+ if( posSamples.empty() || negSamples.empty() )
+ return false;
+
+ //extract features
+ featureSet->extraction( posSamples );
+ const std::vector<Mat> posResponse = featureSet->getResponses();
+
+ featureSet->extraction( negSamples );
+ const std::vector<Mat> negResponse = featureSet->getResponses();
+
+ //compute temp features
+ TrackerFeatureHAAR::Params HAARparameters2;
+ HAARparameters2.numFeatures = ( posSamples.size() + negSamples.size() );
+ HAARparameters2.isIntegral = true;
+ HAARparameters2.rectSize = Size( boundingBox.width, boundingBox.height );
+ Ptr<TrackerFeatureHAAR> trackerFeature2 = Ptr<TrackerFeatureHAAR>( new TrackerFeatureHAAR( HAARparameters2 ) );
+
+ //model estimate
+ model.staticCast<TrackerBoostingModel>()->setMode( TrackerBoostingModel::MODE_NEGATIVE, negSamples );
+ model->modelEstimation( negResponse );
+ model.staticCast<TrackerBoostingModel>()->setMode( TrackerBoostingModel::MODE_POSITIVE, posSamples );
+ model->modelEstimation( posResponse );
+
+ //model update
+ model->modelUpdate();
+
+ //get replaced classifier and change the features
+ std::vector<int> replacedClassifier = model->getTrackerStateEstimator().staticCast<TrackerStateEstimatorAdaBoosting>()->computeReplacedClassifier();
+ std::vector<int> swappedClassified = model->getTrackerStateEstimator().staticCast<TrackerStateEstimatorAdaBoosting>()->computeSwappedClassifier();
+ for ( size_t j = 0; j < replacedClassifier.size(); j++ )
+ {
+ if( replacedClassifier[j] != -1 && swappedClassified[j] != -1 )
+ {
+ featureSet->getTrackerFeature().at( 0 ).second.staticCast<TrackerFeatureHAAR>()->swapFeature( replacedClassifier[j], swappedClassified[j] );
+ featureSet->getTrackerFeature().at( 0 ).second.staticCast<TrackerFeatureHAAR>()->swapFeature( swappedClassified[j],
+ trackerFeature2->getFeatureAt( j ) );
+ }
+ }
+
+ return true;
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/trackerBoostingModel.cpp b/modules/tracking/src/trackerBoostingModel.cpp
new file mode 100644
index 000000000..ead4cb15e
--- /dev/null
+++ b/modules/tracking/src/trackerBoostingModel.cpp
@@ -0,0 +1,123 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "trackerBoostingModel.hpp"
+
+/**
+ * TrackerBoostingModel
+ */
+
+namespace cv
+{
+
+TrackerBoostingModel::TrackerBoostingModel( const Rect& boundingBox )
+{
+
+ mode = MODE_POSITIVE;
+
+ Ptr<TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState> initState =
+ Ptr<TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState>(
+ new TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState( Point2f( boundingBox.x, boundingBox.y ), boundingBox.width,
+ boundingBox.height, true, Mat() ) );
+ trajectory.push_back( initState );
+ maxCMLength = 10;
+}
+
+void TrackerBoostingModel::modelEstimationImpl( const std::vector<Mat>& responses )
+{
+ responseToConfidenceMap( responses, currentConfidenceMap );
+}
+
+void TrackerBoostingModel::modelUpdateImpl()
+{
+
+}
+
+void TrackerBoostingModel::setMode( int trainingMode, const std::vector<Mat>& samples )
+{
+ currentSample.clear();
+ currentSample = samples;
+
+ mode = trainingMode;
+}
+
+std::vector<int> TrackerBoostingModel::getSelectedWeakClassifier()
+{
+ return stateEstimator.staticCast<TrackerStateEstimatorAdaBoosting>()->computeSelectedWeakClassifier();
+}
+
+void TrackerBoostingModel::responseToConfidenceMap( const std::vector<Mat>& responses, ConfidenceMap& confidenceMap )
+{
+ if( currentSample.empty() )
+ {
+ CV_Error( -1, "The samples in Model estimation are empty" );
+ return;
+ }
+
+ for ( size_t i = 0; i < currentSample.size(); i++ )
+ {
+
+ Size currentSize;
+ Point currentOfs;
+ currentSample.at( i ).locateROI( currentSize, currentOfs );
+ bool foreground;
+ if( mode == MODE_POSITIVE || mode == MODE_CLASSIFY )
+ {
+ foreground = true;
+ }
+ else if( mode == MODE_NEGATIVE )
+ {
+ foreground = false;
+ }
+ const Mat resp = responses[0].col( i );
+
+ //create the state
+ Ptr<TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState> currentState = Ptr<
+ TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState>(
+ new TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState( currentOfs, currentSample.at( i ).cols, currentSample.at( i ).rows,
+ foreground, resp ) );
+
+ confidenceMap.push_back( std::make_pair( currentState, 0 ) );
+
+ }
+}
+
+}
diff --git a/modules/tracking/src/trackerBoostingModel.hpp b/modules/tracking/src/trackerBoostingModel.hpp
new file mode 100644
index 000000000..6fa69b032
--- /dev/null
+++ b/modules/tracking/src/trackerBoostingModel.hpp
@@ -0,0 +1,109 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_TRACKER_BOOSTING_MODEL_HPP__
+#define __OPENCV_TRACKER_BOOSTING_MODEL_HPP__
+
+#include "precomp.hpp"
+#include "opencv2/core.hpp"
+
+namespace cv
+{
+
+/**
+ * \brief Implementation of TrackerModel for BOOSTING algorithm
+ */
+class TrackerBoostingModel : public TrackerModel
+{
+ public:
+ enum
+ {
+ MODE_POSITIVE = 1, // mode for positive features
+ MODE_NEGATIVE = 2, // mode for negative features
+ MODE_CLASSIFY = 3 // mode for classify step
+ };
+ /**
+ * \brief Constructor
+ * \param boundingBox The first boundingBox
+ */
+ TrackerBoostingModel( const Rect& boundingBox );
+
+ /**
+ * \brief Destructor
+ */
+ ~TrackerBoostingModel()
+ {
+ }
+ ;
+
+ /**
+ * \brief Set the mode
+ */
+ void setMode( int trainingMode, const std::vector<Mat>& samples );
+
+ /**
+ * \brief Create the ConfidenceMap from a list of responses
+ * \param responses The list of the responses
+ * \param confidenceMap The output
+ */
+ void responseToConfidenceMap( const std::vector<Mat>& responses, ConfidenceMap& confidenceMap );
+
+ /**
+ * \brief return the selected weak classifiers for the detect
+ * @return the selected weak classifiers
+ */
+ std::vector<int> getSelectedWeakClassifier();
+
+ protected:
+ void modelEstimationImpl( const std::vector<Mat>& responses );
+ void modelUpdateImpl();
+
+ private:
+
+ std::vector<Mat> currentSample;
+ std::vector<std::pair<float, float> > meanSigmaPair;
+
+ int mode;
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/modules/tracking/src/trackerFeature.cpp b/modules/tracking/src/trackerFeature.cpp
new file mode 100644
index 000000000..c17e4c733
--- /dev/null
+++ b/modules/tracking/src/trackerFeature.cpp
@@ -0,0 +1,325 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/*
+ * TrackerFeature
+ */
+
+TrackerFeature::~TrackerFeature()
+{
+
+}
+
+void TrackerFeature::compute( const std::vector<Mat>& images, Mat& response )
+{
+ if( images.empty() )
+ return;
+
+ computeImpl( images, response );
+}
+
+Ptr<TrackerFeature> TrackerFeature::create( const String& trackerFeatureType )
+{
+ if( trackerFeatureType.find( "FEATURE2D" ) == 0 )
+ {
+ size_t firstSep = trackerFeatureType.find_first_of( "." );
+ size_t secondSep = trackerFeatureType.find_last_of( "." );
+
+ String detector = trackerFeatureType.substr( firstSep, secondSep - firstSep );
+ String descriptor = trackerFeatureType.substr( secondSep, trackerFeatureType.length() - secondSep );
+
+ return Ptr<TrackerFeatureFeature2d>( new TrackerFeatureFeature2d( detector, descriptor ) );
+ }
+
+ if( trackerFeatureType.find( "HOG" ) == 0 )
+ {
+ return Ptr<TrackerFeatureHOG>( new TrackerFeatureHOG() );
+ }
+
+ if( trackerFeatureType.find( "HAAR" ) == 0 )
+ {
+ return Ptr<TrackerFeatureHAAR>( new TrackerFeatureHAAR() );
+ }
+
+ if( trackerFeatureType.find( "LBP" ) == 0 )
+ {
+ return Ptr<TrackerFeatureLBP>( new TrackerFeatureLBP() );
+ }
+
+ CV_Error( -1, "Tracker feature type not supported" );
+ return Ptr<TrackerFeature>();
+}
+
+String TrackerFeature::getClassName() const
+{
+ return className;
+}
+
+/**
+ * TrackerFeatureFeature2d
+ */
+TrackerFeatureFeature2d::TrackerFeatureFeature2d( String /*detectorType*/, String /*descriptorType*/)
+{
+ className = "FEATURE2D";
+}
+
+TrackerFeatureFeature2d::~TrackerFeatureFeature2d()
+{
+
+}
+
+bool TrackerFeatureFeature2d::computeImpl( const std::vector<Mat>& /*images*/, Mat& /*response*/)
+{
+ return false;
+}
+
+void TrackerFeatureFeature2d::selection( Mat& /*response*/, int /*npoints*/)
+{
+
+}
+
+/**
+ * TrackerFeatureHOG
+ */
+TrackerFeatureHOG::TrackerFeatureHOG()
+{
+ className = "HOG";
+}
+
+TrackerFeatureHOG::~TrackerFeatureHOG()
+{
+
+}
+
+bool TrackerFeatureHOG::computeImpl( const std::vector<Mat>& /*images*/, Mat& /*response*/)
+{
+ return false;
+}
+
+void TrackerFeatureHOG::selection( Mat& /*response*/, int /*npoints*/)
+{
+
+}
+
+/**
+ * TrackerFeatureHAAR
+ */
+
+/**
+ * Parameters
+ */
+
+TrackerFeatureHAAR::Params::Params()
+{
+ numFeatures = 250;
+ rectSize = Size( 100, 100 );
+ isIntegral = false;
+}
+
+TrackerFeatureHAAR::TrackerFeatureHAAR( const TrackerFeatureHAAR::Params ¶meters ) :
+ params( parameters )
+{
+ className = "HAAR";
+
+ CvHaarFeatureParams haarParams;
+ haarParams.numFeatures = params.numFeatures;
+ haarParams.isIntegral = params.isIntegral;
+ featureEvaluator = CvFeatureEvaluator::create( CvFeatureParams::HAAR ).staticCast<CvHaarEvaluator>();
+ featureEvaluator->init( &haarParams, 1, params.rectSize );
+}
+
+TrackerFeatureHAAR::~TrackerFeatureHAAR()
+{
+
+}
+
+CvHaarEvaluator::FeatureHaar& TrackerFeatureHAAR::getFeatureAt( int id )
+{
+ return featureEvaluator->getFeatures( id );
+}
+
+bool TrackerFeatureHAAR::swapFeature( int id, CvHaarEvaluator::FeatureHaar& feature )
+{
+ featureEvaluator->getFeatures( id ) = feature;
+ return true;
+}
+
+bool TrackerFeatureHAAR::swapFeature( int source, int target )
+{
+ CvHaarEvaluator::FeatureHaar feature = featureEvaluator->getFeatures( source );
+ featureEvaluator->getFeatures( source ) = featureEvaluator->getFeatures( target );
+ featureEvaluator->getFeatures( target ) = feature;
+ return true;
+}
+
+bool TrackerFeatureHAAR::extractSelected( const std::vector<int> selFeatures, const std::vector<Mat>& images, Mat& response )
+{
+ if( images.empty() )
+ {
+ return false;
+ }
+
+ int numFeatures = featureEvaluator->getNumFeatures();
+ int numSelFeatures = selFeatures.size();
+
+ //response = Mat_<float>( Size( images.size(), numFeatures ) );
+ response.create( Size( images.size(), numFeatures ), CV_32F );
+ response.setTo( 0 );
+
+ //double t = getTickCount();
+ //for each sample compute #n_feature -> put each feature (n Rect) in response
+ for ( size_t i = 0; i < images.size(); i++ )
+ {
+ int c = images[i].cols;
+ int r = images[i].rows;
+ for ( int j = 0; j < numSelFeatures; j++ )
+ {
+ float res = 0;
+ //const feat
+ CvHaarEvaluator::FeatureHaar& feature = featureEvaluator->getFeatures( selFeatures[j] );
+ feature.eval( images[i], Rect( 0, 0, c, r ), &res );
+ //( Mat_<float>( response ) )( j, i ) = res;
+ response.at<float>( selFeatures[j], i ) = res;
+ }
+ }
+ //t = ( (double) getTickCount() - t ) / getTickFrequency();
+ //std::cout << "StrongClassifierDirectSelection time " << t << std::endl;
+
+ return true;
+}
+
+class Parallel_compute : public cv::ParallelLoopBody
+{
+ private:
+ Ptr<CvHaarEvaluator> featureEvaluator;
+ std::vector<Mat> images;
+ Mat response;
+ //std::vector<CvHaarEvaluator::FeatureHaar> features;
+ public:
+ Parallel_compute( Ptr<CvHaarEvaluator>& fe, const std::vector<Mat>& img, Mat& resp ) :
+ featureEvaluator( fe ),
+ images( img ),
+ response( resp )
+ {
+
+ //features = featureEvaluator->getFeatures();
+ }
+
+ virtual void operator()( const cv::Range &r ) const
+ {
+ for ( register int jf = r.start; jf != r.end; ++jf )
+ {
+ int cols = images[jf].cols;
+ int rows = images[jf].rows;
+ for ( int j = 0; j < featureEvaluator->getNumFeatures(); j++ )
+ {
+ float res = 0;
+ featureEvaluator->getFeatures()[j].eval( images[jf], Rect( 0, 0, cols, rows ), &res );
+ ( Mat_<float>( response ) )( j, jf ) = res;
+ }
+ }
+ }
+};
+
+bool TrackerFeatureHAAR::computeImpl( const std::vector<Mat>& images, Mat& response )
+{
+ if( images.empty() )
+ {
+ return false;
+ }
+
+ int numFeatures = featureEvaluator->getNumFeatures();
+
+ response = Mat_<float>( Size( images.size(), numFeatures ) );
+
+ std::vector<CvHaarEvaluator::FeatureHaar> f = featureEvaluator->getFeatures();
+ //for each sample compute #n_feature -> put each feature (n Rect) in response
+ parallel_for_( Range( 0, images.size() ), Parallel_compute( featureEvaluator, images, response ) );
+
+ /*for ( size_t i = 0; i < images.size(); i++ )
+ {
+ int c = images[i].cols;
+ int r = images[i].rows;
+ for ( int j = 0; j < numFeatures; j++ )
+ {
+ float res = 0;
+ featureEvaluator->getFeatures( j ).eval( images[i], Rect( 0, 0, c, r ), &res );
+ ( Mat_<float>( response ) )( j, i ) = res;
+ }
+ }*/
+
+ return true;
+}
+
+void TrackerFeatureHAAR::selection( Mat& /*response*/, int /*npoints*/)
+{
+
+}
+
+/**
+ * TrackerFeatureLBP
+ */
+TrackerFeatureLBP::TrackerFeatureLBP()
+{
+ className = "LBP";
+}
+
+TrackerFeatureLBP::~TrackerFeatureLBP()
+{
+
+}
+
+bool TrackerFeatureLBP::computeImpl( const std::vector<Mat>& /*images*/, Mat& /*response*/)
+{
+ return false;
+}
+
+void TrackerFeatureLBP::selection( Mat& /*response*/, int /*npoints*/)
+{
+
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/trackerFeatureSet.cpp b/modules/tracking/src/trackerFeatureSet.cpp
new file mode 100644
index 000000000..99ec4944b
--- /dev/null
+++ b/modules/tracking/src/trackerFeatureSet.cpp
@@ -0,0 +1,142 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/*
+ * TrackerFeatureSet
+ */
+
+/*
+ * Constructor
+ */
+TrackerFeatureSet::TrackerFeatureSet()
+{
+ blockAddTrackerFeature = false;
+}
+
+/*
+ * Destructor
+ */
+TrackerFeatureSet::~TrackerFeatureSet()
+{
+
+}
+
+void TrackerFeatureSet::extraction( const std::vector<Mat>& images )
+{
+
+ clearResponses();
+ responses.resize( features.size() );
+
+ for ( size_t i = 0; i < features.size(); i++ )
+ {
+ Mat response;
+ features[i].second->compute( images, response );
+ responses[i] = response;
+ }
+
+ if( !blockAddTrackerFeature )
+ {
+ blockAddTrackerFeature = true;
+ }
+}
+
+void TrackerFeatureSet::selection()
+{
+
+}
+
+void TrackerFeatureSet::removeOutliers()
+{
+
+}
+
+bool TrackerFeatureSet::addTrackerFeature( String trackerFeatureType )
+{
+ if( blockAddTrackerFeature )
+ {
+ return false;
+ }
+ Ptr<TrackerFeature> feature = TrackerFeature::create( trackerFeatureType );
+
+ if( feature == 0 )
+ {
+ return false;
+ }
+
+ features.push_back( std::make_pair( trackerFeatureType, feature ) );
+
+ return true;
+}
+
+bool TrackerFeatureSet::addTrackerFeature( Ptr<TrackerFeature>& feature )
+{
+ if( blockAddTrackerFeature )
+ {
+ return false;
+ }
+
+ String trackerFeatureType = feature->getClassName();
+ features.push_back( std::make_pair( trackerFeatureType, feature ) );
+
+ return true;
+}
+
+const std::vector<std::pair<String, Ptr<TrackerFeature> > >& TrackerFeatureSet::getTrackerFeature() const
+{
+ return features;
+}
+
+const std::vector<Mat>& TrackerFeatureSet::getResponses() const
+{
+ return responses;
+}
+
+void TrackerFeatureSet::clearResponses()
+{
+ responses.clear();
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/trackerMIL.cpp b/modules/tracking/src/trackerMIL.cpp
new file mode 100644
index 000000000..a20f9939c
--- /dev/null
+++ b/modules/tracking/src/trackerMIL.cpp
@@ -0,0 +1,273 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include "trackerMILModel.hpp"
+
+namespace cv
+{
+
+/*
+ * TrackerMIL
+ */
+
+/*
+ * Parameters
+ */
+TrackerMIL::Params::Params()
+{
+ samplerInitInRadius = 3;
+ samplerTrackInRadius = 4;
+ samplerSearchWinSize = 25;
+ samplerInitMaxNegNum = 65;
+ samplerTrackMaxPosNum = 100000;
+ samplerTrackMaxNegNum = 65;
+ featureSetNumFeatures = 250;
+}
+
+void TrackerMIL::Params::read( const cv::FileNode& fn )
+{
+ samplerInitInRadius = fn["samplerInitInRadius"];
+ samplerSearchWinSize = fn["samplerSearchWinSize"];
+ samplerInitInRadius = fn["samplerInitInRadius"];
+ samplerTrackInRadius = fn["samplerTrackInRadius"];
+ samplerTrackMaxPosNum = fn["samplerTrackMaxPosNum"];
+ samplerTrackMaxNegNum = fn["samplerTrackMaxNegNum"];
+ featureSetNumFeatures = fn["featureSetNumFeatures"];
+}
+
+void TrackerMIL::Params::write( cv::FileStorage& fs ) const
+{
+ fs << "samplerInitInRadius" << samplerInitInRadius;
+ fs << "samplerSearchWinSize" << samplerSearchWinSize;
+ fs << "samplerInitInRadius" << samplerInitInRadius;
+ fs << "samplerTrackInRadius" << samplerTrackInRadius;
+ fs << "samplerTrackMaxPosNum" << samplerTrackMaxPosNum;
+ fs << "samplerTrackMaxNegNum" << samplerTrackMaxNegNum;
+ fs << "featureSetNumFeatures" << featureSetNumFeatures;
+
+}
+
+/*
+ * Constructor
+ */
+TrackerMIL::TrackerMIL( const TrackerMIL::Params ¶meters ) :
+ params( parameters )
+{
+ isInit = false;
+}
+
+/*
+ * Destructor
+ */
+TrackerMIL::~TrackerMIL()
+{
+
+}
+
+void TrackerMIL::read( const cv::FileNode& fn )
+{
+ params.read( fn );
+}
+
+void TrackerMIL::write( cv::FileStorage& fs ) const
+{
+ params.write( fs );
+}
+
+void TrackerMIL::compute_integral( const Mat & img, Mat & ii_img )
+{
+ Mat ii;
+ std::vector<Mat> ii_imgs;
+ integral( img, ii, CV_32F );
+ split( ii, ii_imgs );
+ ii_img = ii_imgs[0];
+}
+
+bool TrackerMIL::initImpl( const Mat& image, const Rect& boundingBox )
+{
+ Mat intImage;
+ compute_integral( image, intImage );
+ TrackerSamplerCSC::Params CSCparameters;
+ CSCparameters.initInRad = params.samplerInitInRadius;
+ CSCparameters.searchWinSize = params.samplerSearchWinSize;
+ CSCparameters.initMaxNegNum = params.samplerInitMaxNegNum;
+ CSCparameters.trackInPosRad = params.samplerTrackInRadius;
+ CSCparameters.trackMaxPosNum = params.samplerTrackMaxPosNum;
+ CSCparameters.trackMaxNegNum = params.samplerTrackMaxNegNum;
+
+ Ptr<TrackerSamplerAlgorithm> CSCSampler = Ptr<TrackerSamplerCSC>( new TrackerSamplerCSC( CSCparameters ) );
+ if( !sampler->addTrackerSamplerAlgorithm( CSCSampler ) )
+ return false;
+
+ //or add CSC sampler with default parameters
+ //sampler->addTrackerSamplerAlgorithm( "CSC" );
+
+ //Positive sampling
+ CSCSampler.staticCast<TrackerSamplerCSC>()->setMode( TrackerSamplerCSC::MODE_INIT_POS );
+ sampler->sampling( intImage, boundingBox );
+ std::vector<Mat> posSamples = sampler->getSamples();
+
+ //Negative sampling
+ CSCSampler.staticCast<TrackerSamplerCSC>()->setMode( TrackerSamplerCSC::MODE_INIT_NEG );
+ sampler->sampling( intImage, boundingBox );
+ std::vector<Mat> negSamples = sampler->getSamples();
+
+ if( posSamples.empty() || negSamples.empty() )
+ return false;
+
+ //compute HAAR features
+ TrackerFeatureHAAR::Params HAARparameters;
+ HAARparameters.numFeatures = params.featureSetNumFeatures;
+ HAARparameters.rectSize = Size( boundingBox.width, boundingBox.height );
+ HAARparameters.isIntegral = true;
+ Ptr<TrackerFeature> trackerFeature = Ptr<TrackerFeatureHAAR>( new TrackerFeatureHAAR( HAARparameters ) );
+ featureSet->addTrackerFeature( trackerFeature );
+
+ featureSet->extraction( posSamples );
+ const std::vector<Mat> posResponse = featureSet->getResponses();
+
+ featureSet->extraction( negSamples );
+ const std::vector<Mat> negResponse = featureSet->getResponses();
+
+ model = Ptr<TrackerMILModel>( new TrackerMILModel( boundingBox ) );
+ Ptr<TrackerStateEstimatorMILBoosting> stateEstimator = Ptr<TrackerStateEstimatorMILBoosting>(
+ new TrackerStateEstimatorMILBoosting( params.featureSetNumFeatures ) );
+ model->setTrackerStateEstimator( stateEstimator );
+
+ //Run model estimation and update
+ model.staticCast<TrackerMILModel>()->setMode( TrackerMILModel::MODE_POSITIVE, posSamples );
+ model->modelEstimation( posResponse );
+ model.staticCast<TrackerMILModel>()->setMode( TrackerMILModel::MODE_NEGATIVE, negSamples );
+ model->modelEstimation( negResponse );
+ model->modelUpdate();
+
+ return true;
+}
+
+bool TrackerMIL::updateImpl( const Mat& image, Rect& boundingBox )
+{
+ Mat intImage;
+ compute_integral( image, intImage );
+
+ //get the last location [AAM] X(k-1)
+ Ptr<TrackerTargetState> lastLocation = model->getLastTargetState();
+ Rect lastBoundingBox( lastLocation->getTargetPosition().x, lastLocation->getTargetPosition().y, lastLocation->getTargetWidth(),
+ lastLocation->getTargetHeight() );
+
+ //sampling new frame based on last location
+ ( sampler->getSamplers().at( 0 ).second ).staticCast<TrackerSamplerCSC>()->setMode( TrackerSamplerCSC::MODE_DETECT );
+ sampler->sampling( intImage, lastBoundingBox );
+ std::vector<Mat> detectSamples = sampler->getSamples();
+ if( detectSamples.empty() )
+ return false;
+
+ /*//TODO debug samples
+ Mat f;
+ image.copyTo(f);
+
+ for( size_t i = 0; i < detectSamples.size(); i=i+10 )
+ {
+ Size sz;
+ Point off;
+ detectSamples.at(i).locateROI(sz, off);
+ rectangle(f, Rect(off.x,off.y,detectSamples.at(i).cols,detectSamples.at(i).rows), Scalar(255,0,0), 1);
+ }*/
+
+ //extract features from new samples
+ featureSet->extraction( detectSamples );
+ std::vector<Mat> response = featureSet->getResponses();
+
+ //predict new location
+ ConfidenceMap cmap;
+ model.staticCast<TrackerMILModel>()->setMode( TrackerMILModel::MODE_ESTIMATON, detectSamples );
+ model.staticCast<TrackerMILModel>()->responseToConfidenceMap( response, cmap );
+ model->getTrackerStateEstimator().staticCast<TrackerStateEstimatorMILBoosting>()->setCurrentConfidenceMap( cmap );
+
+ if( !model->runStateEstimator() )
+ {
+ return false;
+ }
+
+ Ptr<TrackerTargetState> currentState = model->getLastTargetState();
+ boundingBox = Rect( currentState->getTargetPosition().x, currentState->getTargetPosition().y, currentState->getTargetWidth(),
+ currentState->getTargetHeight() );
+
+ /*//TODO debug
+ rectangle(f, lastBoundingBox, Scalar(0,255,0), 1);
+ rectangle(f, boundingBox, Scalar(0,0,255), 1);
+ imshow("f", f);
+ //waitKey( 0 );*/
+
+ //sampling new frame based on new location
+ //Positive sampling
+ ( sampler->getSamplers().at( 0 ).second ).staticCast<TrackerSamplerCSC>()->setMode( TrackerSamplerCSC::MODE_INIT_POS );
+ sampler->sampling( intImage, boundingBox );
+ std::vector<Mat> posSamples = sampler->getSamples();
+
+ //Negative sampling
+ ( sampler->getSamplers().at( 0 ).second ).staticCast<TrackerSamplerCSC>()->setMode( TrackerSamplerCSC::MODE_INIT_NEG );
+ sampler->sampling( intImage, boundingBox );
+ std::vector<Mat> negSamples = sampler->getSamples();
+
+ if( posSamples.empty() || negSamples.empty() )
+ return false;
+
+ //extract features
+ featureSet->extraction( posSamples );
+ std::vector<Mat> posResponse = featureSet->getResponses();
+
+ featureSet->extraction( negSamples );
+ std::vector<Mat> negResponse = featureSet->getResponses();
+
+ //model estimate
+ model.staticCast<TrackerMILModel>()->setMode( TrackerMILModel::MODE_POSITIVE, posSamples );
+ model->modelEstimation( posResponse );
+ model.staticCast<TrackerMILModel>()->setMode( TrackerMILModel::MODE_NEGATIVE, negSamples );
+ model->modelEstimation( negResponse );
+
+ //model update
+ model->modelUpdate();
+
+ return true;
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/trackerMILModel.cpp b/modules/tracking/src/trackerMILModel.cpp
new file mode 100644
index 000000000..b4cd2211d
--- /dev/null
+++ b/modules/tracking/src/trackerMILModel.cpp
@@ -0,0 +1,126 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include "trackerMILModel.hpp"
+
+/**
+ * TrackerMILModel
+ */
+
+namespace cv
+{
+
+TrackerMILModel::TrackerMILModel( const Rect& boundingBox )
+{
+ currentSample.clear();
+ mode = MODE_POSITIVE;
+ width = boundingBox.width;
+ height = boundingBox.height;
+
+ Ptr<TrackerStateEstimatorMILBoosting::TrackerMILTargetState> initState = Ptr<TrackerStateEstimatorMILBoosting::TrackerMILTargetState>(
+ new TrackerStateEstimatorMILBoosting::TrackerMILTargetState( Point2f( boundingBox.x, boundingBox.y ), boundingBox.width, boundingBox.height,
+ true, Mat() ) );
+ trajectory.push_back( initState );
+}
+
+void TrackerMILModel::responseToConfidenceMap( const std::vector<Mat>& responses, ConfidenceMap& confidenceMap )
+{
+ if( currentSample.empty() )
+ {
+ CV_Error( -1, "The samples in Model estimation are empty" );
+ return;
+ }
+
+ for ( size_t i = 0; i < responses.size(); i++ )
+ {
+ //for each column (one sample) there are #num_feature
+ //get informations from currentSample
+ for ( int j = 0; j < responses.at( i ).cols; j++ )
+ {
+
+ Size currentSize;
+ Point currentOfs;
+ currentSample.at( j ).locateROI( currentSize, currentOfs );
+ bool foreground = false;
+ if( mode == MODE_POSITIVE || mode == MODE_ESTIMATON )
+ {
+ foreground = true;
+ }
+ else if( mode == MODE_NEGATIVE )
+ {
+ foreground = false;
+ }
+
+ //get the column of the HAAR responses
+ Mat singleResponse = responses.at( i ).col( j );
+
+ //create the state
+ Ptr<TrackerStateEstimatorMILBoosting::TrackerMILTargetState> currentState = Ptr<TrackerStateEstimatorMILBoosting::TrackerMILTargetState>(
+ new TrackerStateEstimatorMILBoosting::TrackerMILTargetState( currentOfs, width, height, foreground, singleResponse ) );
+
+ confidenceMap.push_back( std::make_pair( currentState, 0 ) );
+
+ }
+
+ }
+}
+
+void TrackerMILModel::modelEstimationImpl( const std::vector<Mat>& responses )
+{
+ responseToConfidenceMap( responses, currentConfidenceMap );
+
+}
+
+void TrackerMILModel::modelUpdateImpl()
+{
+
+}
+
+void TrackerMILModel::setMode( int trainingMode, const std::vector<Mat>& samples )
+{
+ currentSample.clear();
+ currentSample = samples;
+
+ mode = trainingMode;
+}
+
+}
diff --git a/modules/tracking/src/trackerMILModel.hpp b/modules/tracking/src/trackerMILModel.hpp
new file mode 100644
index 000000000..213e6c71f
--- /dev/null
+++ b/modules/tracking/src/trackerMILModel.hpp
@@ -0,0 +1,103 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_TRACKER_MIL_MODEL_HPP__
+#define __OPENCV_TRACKER_MIL_MODEL_HPP__
+
+#include "opencv2/core.hpp"
+
+namespace cv
+{
+
+/**
+ * \brief Implementation of TrackerModel for MIL algorithm
+ */
+class TrackerMILModel : public TrackerModel
+{
+ public:
+ enum
+ {
+ MODE_POSITIVE = 1, // mode for positive features
+ MODE_NEGATIVE = 2, // mode for negative features
+ MODE_ESTIMATON = 3 // mode for estimation step
+ };
+
+ /**
+ * \brief Constructor
+ * \param boundingBox The first boundingBox
+ */
+ TrackerMILModel( const Rect& boundingBox );
+
+ /**
+ * \brief Destructor
+ */
+ ~TrackerMILModel()
+ {
+ }
+ ;
+
+ /**
+ * \brief Set the mode
+ */
+ void setMode( int trainingMode, const std::vector<Mat>& samples );
+
+ /**
+ * \brief Create the ConfidenceMap from a list of responses
+ * \param responses The list of the responses
+ * \param confidenceMap The output
+ */
+ void responseToConfidenceMap( const std::vector<Mat>& responses, ConfidenceMap& confidenceMap );
+
+ protected:
+ void modelEstimationImpl( const std::vector<Mat>& responses );
+ void modelUpdateImpl();
+
+ private:
+ int mode;
+ std::vector<Mat> currentSample;
+
+ int width; //initial width of the boundingBox
+ int height; //initial height of the boundingBox
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/modules/tracking/src/trackerModel.cpp b/modules/tracking/src/trackerModel.cpp
new file mode 100644
index 000000000..79499d587
--- /dev/null
+++ b/modules/tracking/src/trackerModel.cpp
@@ -0,0 +1,178 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/*
+ * TrackerModel
+ */
+
+TrackerModel::TrackerModel()
+{
+ stateEstimator = Ptr<TrackerStateEstimator>();
+ maxCMLength = 1;
+}
+
+TrackerModel::~TrackerModel()
+{
+
+}
+
+bool TrackerModel::setTrackerStateEstimator( Ptr<TrackerStateEstimator> trackerStateEstimator )
+{
+ if( stateEstimator != 0 )
+ {
+ return false;
+ }
+
+ stateEstimator = trackerStateEstimator;
+ return true;
+}
+
+Ptr<TrackerStateEstimator> TrackerModel::getTrackerStateEstimator() const
+{
+ return stateEstimator;
+}
+
+void TrackerModel::modelEstimation( const std::vector<Mat>& responses )
+{
+ modelEstimationImpl( responses );
+
+}
+
+void TrackerModel::clearCurrentConfidenceMap()
+{
+ currentConfidenceMap.clear();
+}
+
+void TrackerModel::modelUpdate()
+{
+ modelUpdateImpl();
+
+ if( maxCMLength != -1 && (int) confidenceMaps.size() >= maxCMLength - 1 )
+ {
+ int l = maxCMLength / 2;
+ confidenceMaps.erase( confidenceMaps.begin(), confidenceMaps.begin() + l );
+ }
+ if( maxCMLength != -1 && (int) trajectory.size() >= maxCMLength - 1 )
+ {
+ int l = maxCMLength / 2;
+ trajectory.erase( trajectory.begin(), trajectory.begin() + l );
+ }
+ confidenceMaps.push_back( currentConfidenceMap );
+ stateEstimator->update( confidenceMaps );
+
+ clearCurrentConfidenceMap();
+
+}
+
+bool TrackerModel::runStateEstimator()
+{
+ if( stateEstimator == 0 )
+ {
+ CV_Error( -1, "Tracker state estimator is not setted" );
+ return false;
+ }
+ Ptr<TrackerTargetState> targetState = stateEstimator->estimate( confidenceMaps );
+ if( targetState == 0 )
+ return false;
+
+ setLastTargetState( targetState );
+ return true;
+}
+
+void TrackerModel::setLastTargetState( const Ptr<TrackerTargetState>& lastTargetState )
+{
+ trajectory.push_back( lastTargetState );
+}
+
+Ptr<TrackerTargetState> TrackerModel::getLastTargetState() const
+{
+ return trajectory.back();
+}
+
+const std::vector<ConfidenceMap>& TrackerModel::getConfidenceMaps() const
+{
+ return confidenceMaps;
+}
+
+const ConfidenceMap& TrackerModel::getLastConfidenceMap() const
+{
+ return confidenceMaps.back();
+}
+
+/*
+ * TrackerTargetState
+ */
+
+Point2f TrackerTargetState::getTargetPosition() const
+{
+ return targetPosition;
+}
+
+void TrackerTargetState::setTargetPosition( const Point2f& position )
+{
+ targetPosition = position;
+}
+
+int TrackerTargetState::getTargetWidth() const
+{
+ return targetWidth;
+}
+
+void TrackerTargetState::setTargetWidth( int width )
+{
+ targetWidth = width;
+}
+int TrackerTargetState::getTargetHeight() const
+{
+ return targetHeight;
+}
+
+void TrackerTargetState::setTargetHeight( int height )
+{
+ targetHeight = height;
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/trackerSampler.cpp b/modules/tracking/src/trackerSampler.cpp
new file mode 100644
index 000000000..2a0b591ff
--- /dev/null
+++ b/modules/tracking/src/trackerSampler.cpp
@@ -0,0 +1,142 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/*
+ * TrackerSampler
+ */
+
+/*
+ * Constructor
+ */
+TrackerSampler::TrackerSampler()
+{
+ blockAddTrackerSampler = false;
+}
+
+/*
+ * Destructor
+ */
+TrackerSampler::~TrackerSampler()
+{
+
+}
+
+void TrackerSampler::sampling( const Mat& image, Rect boundingBox )
+{
+
+ clearSamples();
+
+ for ( size_t i = 0; i < samplers.size(); i++ )
+ {
+ std::vector<Mat> current_samples;
+ samplers[i].second->sampling( image, boundingBox, current_samples );
+
+ //push in samples all current_samples
+ for ( size_t j = 0; j < current_samples.size(); j++ )
+ {
+ std::vector<Mat>::iterator it = samples.end();
+ samples.insert( it, current_samples.at( j ) );
+ }
+ }
+
+ if( !blockAddTrackerSampler )
+ {
+ blockAddTrackerSampler = true;
+ }
+}
+
+bool TrackerSampler::addTrackerSamplerAlgorithm( String trackerSamplerAlgorithmType )
+{
+ if( blockAddTrackerSampler )
+ {
+ return false;
+ }
+ Ptr<TrackerSamplerAlgorithm> sampler = TrackerSamplerAlgorithm::create( trackerSamplerAlgorithmType );
+
+ if( sampler == 0 )
+ {
+ return false;
+ }
+
+ samplers.push_back( std::make_pair( trackerSamplerAlgorithmType, sampler ) );
+
+ return true;
+}
+
+bool TrackerSampler::addTrackerSamplerAlgorithm( Ptr<TrackerSamplerAlgorithm>& sampler )
+{
+ if( blockAddTrackerSampler )
+ {
+ return false;
+ }
+
+ if( sampler == 0 )
+ {
+ return false;
+ }
+
+ String trackerSamplerAlgorithmType = sampler->getClassName();
+ samplers.push_back( std::make_pair( trackerSamplerAlgorithmType, sampler ) );
+
+ return true;
+}
+
+const std::vector<std::pair<String, Ptr<TrackerSamplerAlgorithm> > >& TrackerSampler::getSamplers() const
+{
+ return samplers;
+}
+
+const std::vector<Mat>& TrackerSampler::getSamples() const
+{
+ return samples;
+}
+
+void TrackerSampler::clearSamples()
+{
+ samples.clear();
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/trackerSamplerAlgorithm.cpp b/modules/tracking/src/trackerSamplerAlgorithm.cpp
new file mode 100644
index 000000000..41d2012cb
--- /dev/null
+++ b/modules/tracking/src/trackerSamplerAlgorithm.cpp
@@ -0,0 +1,382 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include <time.h>
+
+#ifdef _WIN32
+#define TIME( arg ) (((double) clock()) / CLOCKS_PER_SEC)
+#else
+#define TIME( arg ) (time( arg ))
+#endif
+
+namespace cv
+{
+
+/*
+ * TrackerSamplerAlgorithm
+ */
+
+TrackerSamplerAlgorithm::~TrackerSamplerAlgorithm()
+{
+
+}
+
+bool TrackerSamplerAlgorithm::sampling( const Mat& image, Rect boundingBox, std::vector<Mat>& sample )
+{
+ if( image.empty() )
+ return false;
+
+ return samplingImpl( image, boundingBox, sample );
+}
+
+Ptr<TrackerSamplerAlgorithm> TrackerSamplerAlgorithm::create( const String& trackerSamplerType )
+{
+ if( trackerSamplerType.find( "CSC" ) == 0 )
+ {
+ return Ptr<TrackerSamplerCSC>( new TrackerSamplerCSC() );
+ }
+
+ if( trackerSamplerType.find( "CS" ) == 0 )
+ {
+ return Ptr<TrackerSamplerCS>( new TrackerSamplerCS() );
+ }
+
+ CV_Error( -1, "Tracker sampler algorithm type not supported" );
+ return Ptr<TrackerSamplerAlgorithm>();
+}
+
+String TrackerSamplerAlgorithm::getClassName() const
+{
+ return className;
+}
+
+/**
+ * TrackerSamplerCSC
+ */
+
+/**
+ * Parameters
+ */
+
+TrackerSamplerCSC::Params::Params()
+{
+ initInRad = 3;
+ initMaxNegNum = 65;
+ searchWinSize = 25;
+ trackInPosRad = 4;
+ trackMaxNegNum = 65;
+ trackMaxPosNum = 100000;
+
+}
+
+TrackerSamplerCSC::TrackerSamplerCSC( const TrackerSamplerCSC::Params ¶meters ) :
+ params( parameters )
+{
+ className = "CSC";
+ mode = MODE_INIT_POS;
+ rng = RNG( uint64( TIME( 0 ) ) );
+
+}
+
+TrackerSamplerCSC::~TrackerSamplerCSC()
+{
+
+}
+
+bool TrackerSamplerCSC::samplingImpl( const Mat& image, Rect boundingBox, std::vector<Mat>& sample )
+{
+ float inrad = 0;
+ float outrad = 0;
+ int maxnum = 0;
+
+ switch ( mode )
+ {
+ case MODE_INIT_POS:
+ inrad = params.initInRad;
+ sample = sampleImage( image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad );
+ break;
+ case MODE_INIT_NEG:
+ inrad = 2.0f * params.searchWinSize;
+ outrad = 1.5f * params.initInRad;
+ maxnum = params.initMaxNegNum;
+ sample = sampleImage( image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad, outrad, maxnum );
+ break;
+ case MODE_TRACK_POS:
+ inrad = params.trackInPosRad;
+ outrad = 0;
+ maxnum = params.trackMaxPosNum;
+ sample = sampleImage( image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad, outrad, maxnum );
+ break;
+ case MODE_TRACK_NEG:
+ inrad = 1.5f * params.searchWinSize;
+ outrad = params.trackInPosRad + 5;
+ maxnum = params.trackMaxNegNum;
+ sample = sampleImage( image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad, outrad, maxnum );
+ break;
+ case MODE_DETECT:
+ inrad = params.searchWinSize;
+ sample = sampleImage( image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad );
+ break;
+ default:
+ inrad = params.initInRad;
+ sample = sampleImage( image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad );
+ break;
+ }
+ return false;
+}
+
+void TrackerSamplerCSC::setMode( int samplingMode )
+{
+ mode = samplingMode;
+}
+
+std::vector<Mat> TrackerSamplerCSC::sampleImage( const Mat& img, int x, int y, int w, int h, float inrad, float outrad, int maxnum )
+{
+ int rowsz = img.rows - h - 1;
+ int colsz = img.cols - w - 1;
+ float inradsq = inrad * inrad;
+ float outradsq = outrad * outrad;
+ int dist;
+
+ uint minrow = max( 0, (int) y - (int) inrad );
+ uint maxrow = min( (int) rowsz - 1, (int) y + (int) inrad );
+ uint mincol = max( 0, (int) x - (int) inrad );
+ uint maxcol = min( (int) colsz - 1, (int) x + (int) inrad );
+
+ //fprintf(stderr,"inrad=%f minrow=%d maxrow=%d mincol=%d maxcol=%d\n",inrad,minrow,maxrow,mincol,maxcol);
+
+ std::vector<Mat> samples;
+ samples.resize( ( maxrow - minrow + 1 ) * ( maxcol - mincol + 1 ) );
+ int i = 0;
+
+ float prob = ( (float) ( maxnum ) ) / samples.size();
+
+ for ( int r = minrow; r <= int( maxrow ); r++ )
+ for ( int c = mincol; c <= int( maxcol ); c++ )
+ {
+ dist = ( y - r ) * ( y - r ) + ( x - c ) * ( x - c );
+ if( float( rng.uniform( 0.f, 1.f ) ) < prob && dist < inradsq && dist >= outradsq )
+ {
+ samples[i] = img( Rect( c, r, w, h ) );
+ i++;
+ }
+ }
+
+ samples.resize( min( i, maxnum ) );
+ return samples;
+}
+;
+
+/**
+ * TrackerSamplerCS
+ */
+TrackerSamplerCS::Params::Params()
+{
+ overlap = 0.99f;
+ searchFactor = 2;
+}
+
+TrackerSamplerCS::TrackerSamplerCS( const TrackerSamplerCS::Params ¶meters ) :
+ params( parameters )
+{
+ className = "CS";
+ mode = MODE_POSITIVE;
+}
+
+void TrackerSamplerCS::setMode( int samplingMode )
+{
+ mode = samplingMode;
+}
+
+TrackerSamplerCS::~TrackerSamplerCS()
+{
+
+}
+
+bool TrackerSamplerCS::samplingImpl( const Mat& image, Rect boundingBox, std::vector<Mat>& sample )
+{
+
+ trackedPatch = boundingBox;
+ Size imageSize( image.cols, image.rows );
+ validROI = Rect( 0, 0, imageSize.width, imageSize.height );
+
+ Size trackedPatchSize( trackedPatch.width, trackedPatch.height );
+ Rect trackingROI = getTrackingROI( params.searchFactor );
+
+ sample = patchesRegularScan( image, trackingROI, trackedPatchSize );
+
+ return true;
+}
+
+Rect TrackerSamplerCS::getTrackingROI( float searchFactor )
+{
+ Rect searchRegion;
+
+ searchRegion = RectMultiply( trackedPatch, searchFactor );
+ //check
+ if( searchRegion.y + searchRegion.height > validROI.height )
+ searchRegion.height = validROI.height - searchRegion.y;
+ if( searchRegion.x + searchRegion.width > validROI.width )
+ searchRegion.width = validROI.width - searchRegion.x;
+
+ return searchRegion;
+}
+
+Rect TrackerSamplerCS::RectMultiply( const Rect & rect, float f )
+{
+ cv::Rect r_tmp;
+ r_tmp.y = (int) ( rect.y - ( (float) rect.height * f - rect.height ) / 2 );
+ if( r_tmp.y < 0 )
+ r_tmp.y = 0;
+ r_tmp.x = (int) ( rect.x - ( (float) rect.width * f - rect.width ) / 2 );
+ if( r_tmp.x < 0 )
+ r_tmp.x = 0;
+ r_tmp.height = (int) ( rect.height * f );
+ r_tmp.width = (int) ( rect.width * f );
+
+ return r_tmp;
+}
+
+Rect TrackerSamplerCS::getROI() const
+{
+ return ROI;
+}
+
+void TrackerSamplerCS::setCheckedROI( Rect imageROI )
+{
+ int dCol, dRow;
+ dCol = imageROI.x - validROI.x;
+ dRow = imageROI.y - validROI.y;
+ ROI.y = ( dRow < 0 ) ? validROI.y : imageROI.y;
+ ROI.x = ( dCol < 0 ) ? validROI.x : imageROI.x;
+ dCol = imageROI.x + imageROI.width - ( validROI.x + validROI.width );
+ dRow = imageROI.y + imageROI.height - ( validROI.y + validROI.height );
+ ROI.height = ( dRow > 0 ) ? validROI.height + validROI.y - ROI.y : imageROI.height + imageROI.y - ROI.y;
+ ROI.width = ( dCol > 0 ) ? validROI.width + validROI.x - ROI.x : imageROI.width + imageROI.x - ROI.x;
+}
+
+std::vector<Mat> TrackerSamplerCS::patchesRegularScan( const Mat& image, Rect trackingROI, Size patchSize )
+{
+ std::vector<Mat> sample;
+ if( ( validROI == trackingROI ) )
+ ROI = trackingROI;
+ else
+ setCheckedROI( trackingROI );
+
+ if( mode == MODE_POSITIVE )
+ {
+ int num = 4;
+ sample.resize( num );
+ Mat singleSample = image( trackedPatch );
+ for ( int i = 0; i < num; i++ )
+ sample[i] = singleSample;
+ return sample;
+ }
+
+ int stepCol = (int) floor( ( 1.0f - params.overlap ) * (float) patchSize.width + 0.5f );
+ int stepRow = (int) floor( ( 1.0f - params.overlap ) * (float) patchSize.height + 0.5f );
+ if( stepCol <= 0 )
+ stepCol = 1;
+ if( stepRow <= 0 )
+ stepRow = 1;
+
+ Size m_patchGrid;
+ Rect m_rectUpperLeft;
+ Rect m_rectUpperRight;
+ Rect m_rectLowerLeft;
+ Rect m_rectLowerRight;
+ int num;
+
+ m_patchGrid.height = ( (int) ( (float) ( ROI.height - patchSize.height ) / stepRow ) + 1 );
+ m_patchGrid.width = ( (int) ( (float) ( ROI.width - patchSize.width ) / stepCol ) + 1 );
+
+ num = m_patchGrid.width * m_patchGrid.height;
+ sample.resize( num );
+ int curPatch = 0;
+
+ m_rectUpperLeft = m_rectUpperRight = m_rectLowerLeft = m_rectLowerRight = cv::Rect( 0, 0, patchSize.width, patchSize.height );
+ m_rectUpperLeft.y = ROI.y;
+ m_rectUpperLeft.x = ROI.x;
+ m_rectUpperRight.y = ROI.y;
+ m_rectUpperRight.x = ROI.x + ROI.width - patchSize.width;
+ m_rectLowerLeft.y = ROI.y + ROI.height - patchSize.height;
+ m_rectLowerLeft.x = ROI.x;
+ m_rectLowerRight.y = ROI.y + ROI.height - patchSize.height;
+ m_rectLowerRight.x = ROI.x + ROI.width - patchSize.width;
+
+ if( mode == MODE_NEGATIVE )
+ {
+ int numSamples = 4;
+ sample.resize( numSamples );
+ sample[0] = image( m_rectUpperLeft );
+ sample[1] = image( m_rectUpperRight );
+ sample[2] = image( m_rectLowerLeft );
+ sample[3] = image( m_rectLowerRight );
+ return sample;
+ }
+
+ int numPatchesX;
+ int numPatchesY;
+
+ numPatchesX = 0;
+ numPatchesY = 0;
+ for ( int curRow = 0; curRow < ROI.height - patchSize.height + 1; curRow += stepRow )
+ {
+ numPatchesY++;
+
+ for ( int curCol = 0; curCol < ROI.width - patchSize.width + 1; curCol += stepCol )
+ {
+ if( curRow == 0 )
+ numPatchesX++;
+
+ Mat singleSample = image( Rect( curCol + ROI.x, curRow + ROI.y, patchSize.width, patchSize.height ) );
+ sample[curPatch] = singleSample;
+ curPatch++;
+ }
+ }
+
+ CV_Assert( curPatch == num );
+
+ return sample;
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/trackerStateEstimator.cpp b/modules/tracking/src/trackerStateEstimator.cpp
new file mode 100644
index 000000000..3d1f505b9
--- /dev/null
+++ b/modules/tracking/src/trackerStateEstimator.cpp
@@ -0,0 +1,445 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/*
+ * TrackerStateEstimator
+ */
+
+TrackerStateEstimator::~TrackerStateEstimator()
+{
+
+}
+
+Ptr<TrackerTargetState> TrackerStateEstimator::estimate( const std::vector<ConfidenceMap>& confidenceMaps )
+{
+ if( confidenceMaps.empty() )
+ return Ptr<TrackerTargetState>();
+
+ return estimateImpl( confidenceMaps );
+
+}
+
+void TrackerStateEstimator::update( std::vector<ConfidenceMap>& confidenceMaps )
+{
+ if( confidenceMaps.empty() )
+ return;
+
+ return updateImpl( confidenceMaps );
+
+}
+
+Ptr<TrackerStateEstimator> TrackerStateEstimator::create( const String& trackeStateEstimatorType )
+{
+
+ if( trackeStateEstimatorType.find( "SVM" ) == 0 )
+ {
+ return Ptr<TrackerStateEstimatorSVM>( new TrackerStateEstimatorSVM() );
+ }
+
+ if( trackeStateEstimatorType.find( "BOOSTING" ) == 0 )
+ {
+ return Ptr<TrackerStateEstimatorMILBoosting>( new TrackerStateEstimatorMILBoosting() );
+ }
+
+ CV_Error( -1, "Tracker state estimator type not supported" );
+ return Ptr<TrackerStateEstimator>();
+}
+
+String TrackerStateEstimator::getClassName() const
+{
+ return className;
+}
+
+/**
+ * TrackerStateEstimatorMILBoosting::TrackerMILTargetState
+ */
+TrackerStateEstimatorMILBoosting::TrackerMILTargetState::TrackerMILTargetState( const Point2f& position, int width, int height, bool foreground,
+ const Mat& features )
+{
+ setTargetPosition( position );
+ setTargetWidth( width );
+ setTargetHeight( height );
+ setTargetFg( foreground );
+ setFeatures( features );
+}
+
+void TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setTargetFg( bool foreground )
+{
+ isTarget = foreground;
+}
+
+void TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setFeatures( const Mat& features )
+{
+ targetFeatures = features;
+}
+
+bool TrackerStateEstimatorMILBoosting::TrackerMILTargetState::isTargetFg() const
+{
+ return isTarget;
+}
+
+Mat TrackerStateEstimatorMILBoosting::TrackerMILTargetState::getFeatures() const
+{
+ return targetFeatures;
+}
+
+TrackerStateEstimatorMILBoosting::TrackerStateEstimatorMILBoosting( int nFeatures )
+{
+ className = "BOOSTING";
+ trained = false;
+ numFeatures = nFeatures;
+}
+
+TrackerStateEstimatorMILBoosting::~TrackerStateEstimatorMILBoosting()
+{
+
+}
+
+void TrackerStateEstimatorMILBoosting::setCurrentConfidenceMap( ConfidenceMap& confidenceMap )
+{
+ currentConfidenceMap.clear();
+ currentConfidenceMap = confidenceMap;
+}
+
+uint TrackerStateEstimatorMILBoosting::max_idx( const std::vector<float> &v )
+{
+ const float* findPtr = & ( *std::max_element( v.begin(), v.end() ) );
+ const float* beginPtr = & ( *v.begin() );
+ return (uint) ( findPtr - beginPtr );
+}
+
+Ptr<TrackerTargetState> TrackerStateEstimatorMILBoosting::estimateImpl( const std::vector<ConfidenceMap>& /*confidenceMaps*/)
+{
+ //run ClfMilBoost classify in order to compute next location
+ if( currentConfidenceMap.empty() )
+ return Ptr<TrackerTargetState>();
+
+ Mat positiveStates;
+ Mat negativeStates;
+
+ prepareData( currentConfidenceMap, positiveStates, negativeStates );
+
+ std::vector<float> prob = boostMILModel.classify( positiveStates );
+
+ int bestind = max_idx( prob );
+ //float resp = prob[bestind];
+
+ return currentConfidenceMap.at( bestind ).first;
+}
+
+void TrackerStateEstimatorMILBoosting::prepareData( const ConfidenceMap& confidenceMap, Mat& positive, Mat& negative )
+{
+
+ int posCounter = 0;
+ int negCounter = 0;
+
+ for ( size_t i = 0; i < confidenceMap.size(); i++ )
+ {
+ Ptr<TrackerMILTargetState> currentTargetState = confidenceMap.at( i ).first.staticCast<TrackerMILTargetState>();
+ if( currentTargetState->isTargetFg() )
+ posCounter++;
+ else
+ negCounter++;
+ }
+
+ positive.create( posCounter, numFeatures, CV_32FC1 );
+ negative.create( negCounter, numFeatures, CV_32FC1 );
+
+ //TODO change with mat fast access
+ //initialize trainData (positive and negative)
+
+ int pc = 0;
+ int nc = 0;
+ for ( size_t i = 0; i < confidenceMap.size(); i++ )
+ {
+ Ptr<TrackerMILTargetState> currentTargetState = confidenceMap.at( i ).first.staticCast<TrackerMILTargetState>();
+ Mat stateFeatures = currentTargetState->getFeatures();
+
+ if( currentTargetState->isTargetFg() )
+ {
+ for ( int j = 0; j < stateFeatures.rows; j++ )
+ {
+ //fill the positive trainData with the value of the feature j for sample i
+ positive.at<float>( pc, j ) = stateFeatures.at<float>( j, 0 );
+ }
+ pc++;
+ }
+ else
+ {
+ for ( int j = 0; j < stateFeatures.rows; j++ )
+ {
+ //fill the negative trainData with the value of the feature j for sample i
+ negative.at<float>( nc, j ) = stateFeatures.at<float>( j, 0 );
+ }
+ nc++;
+ }
+
+ }
+}
+
+void TrackerStateEstimatorMILBoosting::updateImpl( std::vector<ConfidenceMap>& confidenceMaps )
+{
+
+ if( !trained )
+ {
+ //this is the first time that the classifier is built
+ //init MIL
+ boostMILModel.init();
+ trained = true;
+ }
+
+ ConfidenceMap lastConfidenceMap = confidenceMaps.back();
+ Mat positiveStates;
+ Mat negativeStates;
+
+ prepareData( lastConfidenceMap, positiveStates, negativeStates );
+ //update MIL
+ boostMILModel.update( positiveStates, negativeStates );
+
+}
+
+/**
+ * TrackerStateEstimatorAdaBoosting
+ */
+TrackerStateEstimatorAdaBoosting::TrackerStateEstimatorAdaBoosting( int numClassifer, int initIterations, int nFeatures, Size patchSize, const Rect& ROI )
+{
+ className = "ADABOOSTING";
+ numBaseClassifier = numClassifer;
+ numFeatures = nFeatures;
+ iterationInit = initIterations;
+ initPatchSize = patchSize;
+ trained = false;
+ sampleROI = ROI;
+
+}
+
+Rect TrackerStateEstimatorAdaBoosting::getSampleROI() const
+{
+ return sampleROI;
+}
+
+void TrackerStateEstimatorAdaBoosting::setSampleROI( const Rect& ROI )
+{
+ sampleROI = ROI;
+}
+
+/**
+ * TrackerAdaBoostingTargetState::TrackerAdaBoostingTargetState
+ */
+TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::TrackerAdaBoostingTargetState( const Point2f& position, int width, int height,
+ bool foreground, const Mat& responses )
+{
+ setTargetPosition( position );
+ setTargetWidth( width );
+ setTargetHeight( height );
+
+ setTargetFg( foreground );
+ setTargetResponses( responses );
+}
+
+void TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::setTargetFg( bool foreground )
+{
+ isTarget = foreground;
+}
+
+bool TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::isTargetFg() const
+{
+ return isTarget;
+}
+
+void TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::setTargetResponses( const Mat& responses )
+{
+ targetResponses = responses;
+}
+
+Mat TrackerStateEstimatorAdaBoosting::TrackerAdaBoostingTargetState::getTargetResponses() const
+{
+ return targetResponses;
+}
+
+TrackerStateEstimatorAdaBoosting::~TrackerStateEstimatorAdaBoosting()
+{
+
+}
+void TrackerStateEstimatorAdaBoosting::setCurrentConfidenceMap( ConfidenceMap& confidenceMap )
+{
+ currentConfidenceMap.clear();
+ currentConfidenceMap = confidenceMap;
+}
+
+std::vector<int> TrackerStateEstimatorAdaBoosting::computeReplacedClassifier()
+{
+ return replacedClassifier;
+}
+
+std::vector<int> TrackerStateEstimatorAdaBoosting::computeSwappedClassifier()
+{
+ return swappedClassifier;
+}
+
+std::vector<int> TrackerStateEstimatorAdaBoosting::computeSelectedWeakClassifier()
+{
+ return boostClassifier->getSelectedWeakClassifier();
+}
+
+Ptr<TrackerTargetState> TrackerStateEstimatorAdaBoosting::estimateImpl( const std::vector<ConfidenceMap>& /*confidenceMaps*/ )
+{
+ //run classify in order to compute next location
+ if( currentConfidenceMap.empty() )
+ return Ptr<TrackerTargetState>();
+
+ std::vector<Mat> images;
+
+ for ( size_t i = 0; i < currentConfidenceMap.size(); i++ )
+ {
+ Ptr<TrackerAdaBoostingTargetState> currentTargetState = currentConfidenceMap.at( i ).first.staticCast<TrackerAdaBoostingTargetState>();
+ images.push_back( currentTargetState->getTargetResponses() );
+ }
+
+ int bestIndex;
+ boostClassifier->classifySmooth( images, sampleROI, bestIndex );
+
+ // get bestIndex from classifySmooth
+ return currentConfidenceMap.at( bestIndex ).first;
+
+}
+
+void TrackerStateEstimatorAdaBoosting::updateImpl( std::vector<ConfidenceMap>& confidenceMaps )
+{
+ if( !trained )
+ {
+ //this is the first time that the classifier is built
+ int numWeakClassifier = numBaseClassifier * 10;
+
+ bool useFeatureExchange = true;
+ boostClassifier = Ptr<StrongClassifierDirectSelection>(
+ new StrongClassifierDirectSelection( numBaseClassifier, numWeakClassifier, initPatchSize, sampleROI, useFeatureExchange, iterationInit ) );
+ //init base classifiers
+ boostClassifier->initBaseClassifier();
+
+ trained = true;
+ }
+
+ ConfidenceMap lastConfidenceMap = confidenceMaps.back();
+ bool featureEx = boostClassifier->getUseFeatureExchange();
+
+ replacedClassifier.clear();
+ replacedClassifier.resize( lastConfidenceMap.size(), -1 );
+ swappedClassifier.clear();
+ swappedClassifier.resize( lastConfidenceMap.size(), -1 );
+
+ for ( size_t i = 0; i < lastConfidenceMap.size() / 2; i++ )
+ {
+ Ptr<TrackerAdaBoostingTargetState> currentTargetState = lastConfidenceMap.at( i ).first.staticCast<TrackerAdaBoostingTargetState>();
+
+ int currentFg = 1;
+ if( !currentTargetState->isTargetFg() )
+ currentFg = -1;
+ Mat res = currentTargetState->getTargetResponses();
+
+ boostClassifier->update( res, currentFg );
+ if( featureEx )
+ {
+ replacedClassifier[i] = boostClassifier->getReplacedClassifier();
+ swappedClassifier[i] = boostClassifier->getSwappedClassifier();
+ if( replacedClassifier[i] >= 0 && swappedClassifier[i] >= 0 )
+ boostClassifier->replaceWeakClassifier( replacedClassifier[i] );
+ }
+ else
+ {
+ replacedClassifier[i] = -1;
+ swappedClassifier[i] = -1;
+ }
+
+ int mapPosition = i + lastConfidenceMap.size() / 2;
+ Ptr<TrackerAdaBoostingTargetState> currentTargetState2 = lastConfidenceMap.at( mapPosition ).first.staticCast<TrackerAdaBoostingTargetState>();
+
+ currentFg = 1;
+ if( !currentTargetState2->isTargetFg() )
+ currentFg = -1;
+ const Mat res2 = currentTargetState2->getTargetResponses();
+
+ boostClassifier->update( res2, currentFg );
+ if( featureEx )
+ {
+ replacedClassifier[mapPosition] = boostClassifier->getReplacedClassifier();
+ swappedClassifier[mapPosition] = boostClassifier->getSwappedClassifier();
+ if( replacedClassifier[mapPosition] >= 0 && swappedClassifier[mapPosition] >= 0 )
+ boostClassifier->replaceWeakClassifier( replacedClassifier[mapPosition] );
+ }
+ else
+ {
+ replacedClassifier[mapPosition] = -1;
+ swappedClassifier[mapPosition] = -1;
+ }
+ }
+
+}
+
+/**
+ * TrackerStateEstimatorSVM
+ */
+TrackerStateEstimatorSVM::TrackerStateEstimatorSVM()
+{
+ className = "SVM";
+}
+
+TrackerStateEstimatorSVM::~TrackerStateEstimatorSVM()
+{
+
+}
+
+Ptr<TrackerTargetState> TrackerStateEstimatorSVM::estimateImpl( const std::vector<ConfidenceMap>& confidenceMaps )
+{
+ return confidenceMaps.back().back().first;
+}
+
+void TrackerStateEstimatorSVM::updateImpl( std::vector<ConfidenceMap>& /*confidenceMaps*/)
+{
+
+}
+
+} /* namespace cv */
diff --git a/modules/tracking/src/tracking_init.cpp b/modules/tracking/src/tracking_init.cpp
new file mode 100644
index 000000000..f203058f3
--- /dev/null
+++ b/modules/tracking/src/tracking_init.cpp
@@ -0,0 +1,61 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include "opencv2/tracking.hpp"
+
+namespace cv
+{
+
+CV_INIT_ALGORITHM(TrackerMIL, "TRACKER.MIL",);
+
+CV_INIT_ALGORITHM(TrackerBoosting, "TRACKER.BOOSTING",);
+
+bool initModule_tracking(void)
+{
+ bool all = true;
+ all &= !TrackerMIL_info_auto.name().empty();
+ all &= !TrackerBoosting_info_auto.name().empty();
+
+ return all;
+}
+
+}
diff --git a/modules/tracking/test/test_main.cpp b/modules/tracking/test/test_main.cpp
new file mode 100644
index 000000000..6b2499344
--- /dev/null
+++ b/modules/tracking/test/test_main.cpp
@@ -0,0 +1,3 @@
+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")
diff --git a/modules/tracking/test/test_precomp.hpp b/modules/tracking/test/test_precomp.hpp
new file mode 100644
index 000000000..b83795189
--- /dev/null
+++ b/modules/tracking/test/test_precomp.hpp
@@ -0,0 +1,18 @@
+#ifdef __GNUC__
+# pragma GCC diagnostic ignored "-Wmissing-declarations"
+# if defined __clang__ || defined __APPLE__
+# pragma GCC diagnostic ignored "-Wmissing-prototypes"
+# pragma GCC diagnostic ignored "-Wextra"
+# endif
+#endif
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include <iostream>
+#include "opencv2/ts.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/tracking.hpp"
+#include "opencv2/highgui.hpp"
+
+#endif
diff --git a/modules/tracking/test/test_tracker.cpp b/modules/tracking/test/test_tracker.cpp
new file mode 100644
index 000000000..900772b92
--- /dev/null
+++ b/modules/tracking/test/test_tracker.cpp
@@ -0,0 +1,130 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ // By downloading, copying, installing or using the software you agree to this license.
+ // If you do not agree to this license, do not download, install,
+ // copy or use the software.
+ //
+ //
+ // License Agreement
+ // For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ // * Redistribution's of source code must retain the above copyright notice,
+ // this list of conditions and the following disclaimer.
+ //
+ // * Redistribution's in binary form must reproduce the above copyright notice,
+ // this list of conditions and the following disclaimer in the documentation
+ // and/or other materials provided with the distribution.
+ //
+ // * The name of the copyright holders may not be used to endorse or promote products
+ // derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "test_precomp.hpp"
+#include "opencv2/tracking.hpp"
+
+using namespace cv;
+using namespace std;
+
+class CV_TrackerBaseTest : public cvtest::BaseTest
+{
+ public:
+ CV_TrackerBaseTest();
+ virtual ~CV_TrackerBaseTest();
+
+};
+
+CV_TrackerBaseTest::CV_TrackerBaseTest()
+{
+
+}
+
+CV_TrackerBaseTest::~CV_TrackerBaseTest()
+{
+
+}
+
+/************************************ TrackerMIL ************************************/
+
+class CV_TrackerMILTest : public CV_TrackerBaseTest
+{
+ public:
+ CV_TrackerMILTest();
+ ~CV_TrackerMILTest();
+
+ protected:
+ void run( int );
+};
+
+CV_TrackerMILTest::CV_TrackerMILTest()
+{
+}
+
+CV_TrackerMILTest::~CV_TrackerMILTest()
+{
+}
+
+void CV_TrackerMILTest::run( int )
+{
+ ts->set_failed_test_info( cvtest::TS::FAIL_GENERIC );
+ ts->printf( cvtest::TS::LOG, "CV_TrackerMILTest to be implemented" );
+}
+
+TEST(DISABLED_Tracking_TrackerMIL, accuracy)
+{
+ CV_TrackerMILTest test;
+ test.safe_run();
+}
+
+/************************************ TrackerBoosting ************************************/
+
+class CV_TrackerBoostingTest : public CV_TrackerBaseTest
+{
+ public:
+ CV_TrackerBoostingTest();
+ ~CV_TrackerBoostingTest();
+
+ protected:
+ void run( int );
+};
+
+CV_TrackerBoostingTest::CV_TrackerBoostingTest()
+{
+}
+
+CV_TrackerBoostingTest::~CV_TrackerBoostingTest()
+{
+}
+
+void CV_TrackerBoostingTest::run( int )
+{
+ ts->set_failed_test_info( cvtest::TS::FAIL_GENERIC );
+ ts->printf( cvtest::TS::LOG, "CV_TrackerBoostingTest to be implemented" );
+}
+
+TEST(DISABLED_Tracking_TrackerBoosting, accuracy)
+{
+ CV_TrackerBoostingTest test;
+ test.safe_run();
+}
+
+/* End of file. */