diff options
Diffstat (limited to 'thirdparty/linux/include/opencv2/tracking/tracker.hpp')
| -rw-r--r-- | thirdparty/linux/include/opencv2/tracking/tracker.hpp | 1485 |
1 files changed, 1485 insertions, 0 deletions
diff --git a/thirdparty/linux/include/opencv2/tracking/tracker.hpp b/thirdparty/linux/include/opencv2/tracking/tracker.hpp new file mode 100644 index 0000000..3b32033 --- /dev/null +++ b/thirdparty/linux/include/opencv2/tracking/tracker.hpp @@ -0,0 +1,1485 @@ +/*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> + + +#define BOILERPLATE_CODE(name,classname) \ + static Ptr<classname> createTracker(const classname::Params ¶meters=classname::Params());\ + virtual ~classname(){}; + +/* + * 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/doc/uml + * + */ + +namespace cv +{ + +//! @addtogroup tracking +//! @{ + +/************************************ TrackerFeature Base Classes ************************************/ + +/** @brief Abstract base class for TrackerFeature that represents the feature. + */ +class CV_EXPORTS TrackerFeature +{ + public: + virtual ~TrackerFeature(); + + /** @brief Compute the features in the images collection + @param images The images + @param response The output response + */ + void compute( const std::vector<Mat>& images, Mat& response ); + + /** @brief Create TrackerFeature by tracker feature type + @param trackerFeatureType The TrackerFeature name + + The modes available now: + + - "HAAR" -- Haar Feature-based + + The modes that will be available soon: + + - "HOG" -- Histogram of Oriented Gradients features + - "LBP" -- Local Binary Pattern features + - "FEATURE2D" -- All types of Feature2D + */ + 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 + + @note This method modifies the response parameter + */ + virtual void selection( Mat& response, int npoints ) = 0; + + /** @brief Get the name of the specific TrackerFeature + */ + 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 + +@cite AAM Feature Extraction and Feature Set Refinement (Feature Processing and Feature Selection). +See table I and section III C @cite AMVOT Appearance modelling -\> Visual representation (Table II, +section 3.1 - 3.2) + +TrackerFeatureSet is an aggregation of TrackerFeature + +@sa + TrackerFeature + + */ +class CV_EXPORTS TrackerFeatureSet +{ + public: + + TrackerFeatureSet(); + + ~TrackerFeatureSet(); + + /** @brief Extract features from the images collection + @param images The input images + */ + void extraction( const std::vector<Mat>& images ); + + /** @brief Identify most effective features for all feature types (optional) + */ + void selection(); + + /** @brief Remove outliers for all feature types (optional) + */ + void removeOutliers(); + + /** @brief Add TrackerFeature in the collection. Return true if TrackerFeature is added, false otherwise + @param trackerFeatureType The TrackerFeature name + + The modes available now: + + - "HAAR" -- Haar Feature-based + + The modes that will be available soon: + + - "HOG" -- Histogram of Oriented Gradients features + - "LBP" -- Local Binary Pattern features + - "FEATURE2D" -- All types of Feature2D + + Example TrackerFeatureSet::addTrackerFeature : : + @code + //sample usage: + + Ptr<TrackerFeature> trackerFeature = new TrackerFeatureHAAR( HAARparameters ); + featureSet->addTrackerFeature( trackerFeature ); + + //or add CSC sampler with default parameters + //featureSet->addTrackerFeature( "HAAR" ); + @endcode + @note If you use the second method, you must initialize the TrackerFeature + */ + bool addTrackerFeature( String trackerFeatureType ); + + /** @overload + @param feature The TrackerFeature class + */ + bool addTrackerFeature( Ptr<TrackerFeature>& feature ); + + /** @brief Get the TrackerFeature collection (TrackerFeature name, TrackerFeature pointer) + */ + const std::vector<std::pair<String, Ptr<TrackerFeature> > >& getTrackerFeature() const; + + /** @brief Get the responses + + @note Be sure to call extraction before getResponses Example TrackerFeatureSet::getResponses : : + */ + 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 TrackerSamplerAlgorithm +{ + public: + /** + * \brief Destructor + */ + virtual ~TrackerSamplerAlgorithm(); + + /** @brief Create TrackerSamplerAlgorithm by tracker sampler type. + @param trackerSamplerType The trackerSamplerType name + + The modes available now: + + - "CSC" -- Current State Center + - "CS" -- Current State + */ + static Ptr<TrackerSamplerAlgorithm> create( const String& trackerSamplerType ); + + /** @brief Computes the regions starting from a position in an image. + + Return true if samples are computed, false otherwise + + @param image The current frame + @param boundingBox The bounding box from which regions can be calculated + + @param sample The computed samples @cite AAM Fig. 1 variable Sk + */ + bool sampling( const Mat& image, Rect boundingBox, std::vector<Mat>& sample ); + + /** @brief Get the name of the specific TrackerSamplerAlgorithm + */ + 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 + */ + +/** @brief Class that manages the sampler in order to select regions for the update the model of the tracker + +@cite AAM Sampling e Labeling. See table I and section III B + +TrackerSampler is an aggregation of TrackerSamplerAlgorithm +@sa + TrackerSamplerAlgorithm + */ +class CV_EXPORTS TrackerSampler +{ + public: + + /** + * \brief Constructor + */ + TrackerSampler(); + + /** + * \brief Destructor + */ + ~TrackerSampler(); + + /** @brief Computes the regions starting from a position in an image + @param image The current frame + @param boundingBox The bounding box from which regions can be calculated + */ + void sampling( const Mat& image, Rect boundingBox ); + + /** @brief Return the collection of the TrackerSamplerAlgorithm + */ + const std::vector<std::pair<String, Ptr<TrackerSamplerAlgorithm> > >& getSamplers() const; + + /** @brief Return the samples from all TrackerSamplerAlgorithm, @cite AAM Fig. 1 variable Sk + */ + const std::vector<Mat>& getSamples() const; + + /** @brief Add TrackerSamplerAlgorithm in the collection. Return true if sampler is added, false otherwise + @param trackerSamplerAlgorithmType The TrackerSamplerAlgorithm name + + The modes available now: + - "CSC" -- Current State Center + - "CS" -- Current State + - "PF" -- Particle Filtering + + Example TrackerSamplerAlgorithm::addTrackerSamplerAlgorithm : : + @code + 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" ); + @endcode + @note If you use the second method, you must initialize the TrackerSamplerAlgorithm + */ + bool addTrackerSamplerAlgorithm( String trackerSamplerAlgorithmType ); + + /** @overload + @param sampler The TrackerSamplerAlgorithm + */ + 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. + +See @cite AAM \f$\hat{x}^{i}_{k}\f$ all the states candidates. + +Inherits this class with your Target state, In own implementation you can add scale variation, +width, height, orientation, etc. + */ +class CV_EXPORTS 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 \f$k\f$ (all states and scores) + +See @cite AAM The set of the pair \f$\langle \hat{x}^{i}_{k}, C^{i}_{k} \rangle\f$ +@sa TrackerTargetState + */ +typedef std::vector<std::pair<Ptr<TrackerTargetState>, float> > ConfidenceMap; + +/** @brief Represents the estimate states for all frames + +@cite AAM \f$x_{k}\f$ is the trajectory of the target up to time \f$k\f$ + +@sa TrackerTargetState + */ +typedef std::vector<Ptr<TrackerTargetState> > Trajectory; + +/** @brief Abstract base class for TrackerStateEstimator that estimates the most likely target state. + +See @cite AAM State estimator + +See @cite AMVOT Statistical modeling (Fig. 3), Table III (generative) - IV (discriminative) - V (hybrid) + */ +class CV_EXPORTS TrackerStateEstimator +{ + public: + virtual ~TrackerStateEstimator(); + + /** @brief Estimate the most likely target state, return the estimated state + @param confidenceMaps The overall appearance model as a list of :cConfidenceMap + */ + Ptr<TrackerTargetState> estimate( const std::vector<ConfidenceMap>& confidenceMaps ); + + /** @brief Update the ConfidenceMap with the scores + @param confidenceMaps The overall appearance model as a list of :cConfidenceMap + */ + void update( std::vector<ConfidenceMap>& confidenceMaps ); + + /** @brief Create TrackerStateEstimator by tracker state estimator type + @param trackeStateEstimatorType The TrackerStateEstimator name + + The modes available now: + + - "BOOSTING" -- Boosting-based discriminative appearance models. See @cite AMVOT section 4.4 + + The modes available soon: + + - "SVM" -- SVM-based discriminative appearance models. See @cite AMVOT section 4.5 + */ + static Ptr<TrackerStateEstimator> create( const String& trackeStateEstimatorType ); + + /** @brief Get the name of the specific TrackerStateEstimator + */ + 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 + +See @cite AAM Ak + +Inherits this with your TrackerModel + */ +class CV_EXPORTS TrackerModel +{ + public: + + /** + * \brief Constructor + */ + TrackerModel(); + + /** + * \brief Destructor + */ + virtual ~TrackerModel(); + + /** @brief Set TrackerEstimator, return true if the tracker state estimator is added, false otherwise + @param trackerStateEstimator The TrackerStateEstimator + @note You can add only one TrackerStateEstimator + */ + bool setTrackerStateEstimator( Ptr<TrackerStateEstimator> trackerStateEstimator ); + + /** @brief Estimate the most likely target location + + @cite AAM ME, Model Estimation table I + @param responses Features extracted from TrackerFeatureSet + */ + void modelEstimation( const std::vector<Mat>& responses ); + + /** @brief Update the model + + @cite 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 TrackerTargetState in the Trajectory + @param lastTargetState The current TrackerTargetState + */ + void setLastTargetState( const Ptr<TrackerTargetState>& lastTargetState ); + + /** @brief Get the last TrackerTargetState from Trajectory + */ + Ptr<TrackerTargetState> getLastTargetState() const; + + /** @brief Get the list of the ConfidenceMap + */ + const std::vector<ConfidenceMap>& getConfidenceMaps() const; + + /** @brief Get the last ConfidenceMap for the current frame + */ + const ConfidenceMap& getLastConfidenceMap() const; + + /** @brief Get the TrackerStateEstimator + */ + 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 Base abstract class for the long-term tracker: + */ +class CV_EXPORTS_W Tracker : public virtual Algorithm +{ + public: + + virtual ~Tracker(); + + /** @brief Initialize the tracker with a know bounding box that surrounding the target + @param image The initial frame + @param boundingBox The initial boundig box + + @return True if initialization went succesfully, false otherwise + */ + CV_WRAP bool init( const Mat& image, const Rect2d& boundingBox ); + + /** @brief Update the tracker, find the new most likely bounding box for the target + @param image The current frame + @param boundingBox The boundig box that represent the new target location, if true was returned, not + modified otherwise + + @return True means that target was located and false means that tracker cannot locate target in + current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed + missing from the frame (say, out of sight) + */ + CV_WRAP bool update( const Mat& image, CV_OUT Rect2d& boundingBox ); + + /** @brief Creates a tracker by its name. + @param trackerType Tracker type + + The following detector types are supported: + + - "MIL" -- TrackerMIL + - "BOOSTING" -- TrackerBoosting + */ + CV_WRAP static Ptr<Tracker> create( const String& trackerType ); + + virtual void read( const FileNode& fn )=0; + virtual void write( FileStorage& fs ) const=0; + + Ptr<TrackerModel> getModel() + { + return model; + } + + protected: + + virtual bool initImpl( const Mat& image, const Rect2d& boundingBox ) = 0; + virtual bool updateImpl( const Mat& image, Rect2d& boundingBox ) = 0; + + bool isInit; + + Ptr<TrackerFeatureSet> featureSet; + Ptr<TrackerSampler> sampler; + Ptr<TrackerModel> model; +}; + + +/************************************ Specific TrackerStateEstimator Classes ************************************/ + +/** @brief TrackerStateEstimator based on Boosting + */ +class CV_EXPORTS 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() + { + } + ; + + /** @brief Set label: true for target foreground, false for background + @param foreground Label for background/foreground + */ + void setTargetFg( bool foreground ); + /** @brief Set the features extracted from TrackerFeatureSet + @param features The features extracted + */ + void setFeatures( const Mat& features ); + /** @brief Get the label. Return true for target foreground, false for background + */ + bool isTargetFg() const; + /** @brief Get the features extracted + */ + Mat getFeatures() const; + + private: + bool isTarget; + Mat targetFeatures; + }; + + /** @brief Constructor + @param nFeatures Number of features for each sample + */ + TrackerStateEstimatorMILBoosting( int nFeatures = 250 ); + ~TrackerStateEstimatorMILBoosting(); + + /** @brief Set the current confidenceMap + @param confidenceMap The current :cConfidenceMap + */ + 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 TrackerStateEstimatorAdaBoosting based on ADA-Boosting + */ +class CV_EXPORTS TrackerStateEstimatorAdaBoosting : public TrackerStateEstimator +{ + public: + /** @brief Implementation of the target state for TrackerAdaBoostingTargetState + */ + 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() + { + } + ; + + /** @brief Set the features extracted from TrackerFeatureSet + @param responses The features extracted + */ + void setTargetResponses( const Mat& responses ); + /** @brief Set label: true for target foreground, false for background + @param foreground Label for background/foreground + */ + void setTargetFg( bool foreground ); + /** @brief Get the features extracted + */ + Mat getTargetResponses() const; + /** @brief Get the label. Return true for target foreground, false for background + */ + 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 + */ + Rect getSampleROI() const; + + /** @brief Set the sampling ROI + @param ROI the sampling ROI + */ + void setSampleROI( const Rect& ROI ); + + /** @brief Set the current confidenceMap + @param confidenceMap The current :cConfidenceMap + */ + void setCurrentConfidenceMap( ConfidenceMap& confidenceMap ); + + /** @brief Get the list of the selected weak classifiers for the classification step + */ + std::vector<int> computeSelectedWeakClassifier(); + + /** @brief Get the list of the weak classifiers that should be replaced + */ + std::vector<int> computeReplacedClassifier(); + + /** @brief Get the list of the weak classifiers that replace those to be replaced + */ + 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 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), used by MIL algorithm TrackerMIL + */ +class CV_EXPORTS 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 + }; + + /** @brief Constructor + @param parameters TrackerSamplerCSC parameters TrackerSamplerCSC::Params + */ + TrackerSamplerCSC( const TrackerSamplerCSC::Params ¶meters = TrackerSamplerCSC::Params() ); + + /** @brief Set the sampling mode of TrackerSamplerCSC + @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 + */ + 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), used by algorithm TrackerBoosting + */ +class CV_EXPORTS 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 + }; + /** @brief Constructor + @param parameters TrackerSamplerCS parameters TrackerSamplerCS::Params + */ + TrackerSamplerCS( const TrackerSamplerCS::Params ¶meters = TrackerSamplerCS::Params() ); + + /** @brief Set the sampling mode of TrackerSamplerCS + @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 + */ + 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; + +}; + +/** @brief This sampler is based on particle filtering. + +In principle, it can be thought of as performing some sort of optimization (and indeed, this +tracker uses opencv's optim module), where tracker seeks to find the rectangle in given frame, +which is the most *"similar"* to the initial rectangle (the one, given through the constructor). + +The optimization performed is stochastic and somehow resembles genetic algorithms, where on each new +image received (submitted via TrackerSamplerPF::sampling()) we start with the region bounded by +boundingBox, then generate several "perturbed" boxes, take the ones most similar to the original. +This selection round is repeated several times. At the end, we hope that only the most promising box +remaining, and these are combined to produce the subrectangle of image, which is put as a sole +element in array sample. + +It should be noted, that the definition of "similarity" between two rectangles is based on comparing +their histograms. As experiments show, tracker is *not* very succesfull if target is assumed to +strongly change its dimensions. + */ +class CV_EXPORTS TrackerSamplerPF : public TrackerSamplerAlgorithm +{ +public: + /** @brief This structure contains all the parameters that can be varied during the course of sampling + algorithm. Below is the structure exposed, together with its members briefly explained with + reference to the above discussion on algorithm's working. + */ + struct CV_EXPORTS Params + { + Params(); + int iterationNum; //!< number of selection rounds + int particlesNum; //!< number of "perturbed" boxes on each round + double alpha; //!< with each new round we exponentially decrease the amount of "perturbing" we allow (like in simulated annealing) + //!< and this very alpha controls how fast annealing happens, ie. how fast perturbing decreases + Mat_<double> std; //!< initial values for perturbing (1-by-4 array, as each rectangle is given by 4 values -- coordinates of opposite vertices, + //!< hence we have 4 values to perturb) + }; + /** @brief Constructor + @param chosenRect Initial rectangle, that is supposed to contain target we'd like to track. + @param parameters + */ + TrackerSamplerPF(const Mat& chosenRect,const TrackerSamplerPF::Params ¶meters = TrackerSamplerPF::Params()); +protected: + bool samplingImpl( const Mat& image, Rect boundingBox, std::vector<Mat>& sample ); +private: + Params params; + Ptr<MinProblemSolver> _solver; + Ptr<MinProblemSolver::Function> _function; +}; + +/************************************ Specific TrackerFeature Classes ************************************/ + +/** + * \brief TrackerFeature based on Feature2D + */ +class CV_EXPORTS 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 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 features, used by TrackerMIL and many others algorithms +@note HAAR features implementation is copied from apps/traincascade and modified according to MIL + */ +class CV_EXPORTS 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 + }; + + /** @brief Constructor + @param parameters TrackerFeatureHAAR parameters TrackerFeatureHAAR::Params + */ + 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 Collection of response for the specific TrackerFeature + */ + bool extractSelected( const std::vector<int> selFeatures, const std::vector<Mat>& images, Mat& response ); + + /** @brief Identify most effective features + @param response Collection of response for the specific TrackerFeature + @param npoints Max number of features + + @note This method modifies the response parameter + */ + 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 in position id + @param id The position + */ + 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 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 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. The implementation is +based on @cite MIL . + +Original code can be found here <http://vision.ucsd.edu/~bbabenko/project_miltrack.shtml> + */ +class CV_EXPORTS 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 Constructor + @param parameters MIL parameters TrackerMIL::Params + */ + BOILERPLATE_CODE("MIL",TrackerMIL); +}; + +/** @brief 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. The implementation is based on @cite OLB . + */ +class CV_EXPORTS 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 Constructor + @param parameters BOOSTING parameters TrackerBoosting::Params + */ + BOILERPLATE_CODE("BOOSTING",TrackerBoosting); +}; + +/** @brief Median Flow tracker implementation. + +Implementation of a paper @cite MedianFlow . + +The tracker is suitable for very smooth and predictable movements when object is visible throughout +the whole sequence. It's quite and accurate for this type of problems (in particular, it was shown +by authors to outperform MIL). During the implementation period the code at +<http://www.aonsquared.co.uk/node/5>, the courtesy of the author Arthur Amarra, was used for the +reference purpose. + */ +class CV_EXPORTS TrackerMedianFlow : public Tracker +{ + public: + struct CV_EXPORTS Params + { + Params(); + int pointsInGrid; //!<square root of number of keypoints used; increase it to trade + //!<accurateness for speed; default value is sensible and recommended + void read( const FileNode& /*fn*/ ); + void write( FileStorage& /*fs*/ ) const; + }; + + /** @brief Constructor + @param parameters Median Flow parameters TrackerMedianFlow::Params + */ + BOILERPLATE_CODE("MEDIANFLOW",TrackerMedianFlow); +}; + +/** @brief TLD is a novel tracking framework that explicitly decomposes the long-term tracking task into +tracking, learning and detection. + +The tracker follows the object from frame to frame. The detector localizes all appearances that +have been observed so far and corrects the tracker if necessary. The learning estimates detector’s +errors and updates it to avoid these errors in the future. The implementation is based on @cite TLD . + +The Median Flow algorithm (see cv::TrackerMedianFlow) was chosen as a tracking component in this +implementation, following authors. Tracker is supposed to be able to handle rapid motions, partial +occlusions, object absence etc. + */ +class CV_EXPORTS TrackerTLD : public Tracker +{ + public: + struct CV_EXPORTS Params + { + Params(); + void read( const FileNode& /*fn*/ ); + void write( FileStorage& /*fs*/ ) const; + }; + + /** @brief Constructor + @param parameters TLD parameters TrackerTLD::Params + */ + BOILERPLATE_CODE("TLD",TrackerTLD); +}; + +/** @brief KCF is a novel tracking framework that utilizes properties of circulant matrix to enhance the processing speed. + * This tracking method is an implementation of @cite KCF_ECCV which is extended to KFC with color-names features (@cite KCF_CN). + * The original paper of KCF is available at <http://home.isr.uc.pt/~henriques/circulant/index.html> + * as well as the matlab implementation. For more information about KCF with color-names features, please refer to + * <http://www.cvl.isy.liu.se/research/objrec/visualtracking/colvistrack/index.html>. + */ +class CV_EXPORTS TrackerKCF : public Tracker +{ +public: + /** + * \brief Feature type to be used in the tracking grayscale, colornames, compressed color-names + * The modes available now: + - "GRAY" -- Use grayscale values as the feature + - "CN" -- Color-names feature + */ + enum MODE { + GRAY = (1u << 0), + CN = (1u << 1), + CUSTOM = (1u << 2) + }; + + struct CV_EXPORTS Params + { + /** + * \brief Constructor + */ + Params(); + + /** + * \brief Read parameters from file, currently unused + */ + void read(const FileNode& /*fn*/); + + /** + * \brief Read parameters from file, currently unused + */ + void write(FileStorage& /*fs*/) const; + + double sigma; //!< gaussian kernel bandwidth + double lambda; //!< regularization + double interp_factor; //!< linear interpolation factor for adaptation + double output_sigma_factor; //!< spatial bandwidth (proportional to target) + double pca_learning_rate; //!< compression learning rate + bool resize; //!< activate the resize feature to improve the processing speed + bool split_coeff; //!< split the training coefficients into two matrices + bool wrap_kernel; //!< wrap around the kernel values + bool compress_feature; //!< activate the pca method to compress the features + int max_patch_size; //!< threshold for the ROI size + int compressed_size; //!< feature size after compression + unsigned int desc_pca; //!< compressed descriptors of TrackerKCF::MODE + unsigned int desc_npca; //!< non-compressed descriptors of TrackerKCF::MODE + }; + + virtual void setFeatureExtractor(void(*)(const Mat, const Rect, Mat&), bool pca_func = false); + + /** @brief Constructor + @param parameters KCF parameters TrackerKCF::Params + */ + BOILERPLATE_CODE("KCF", TrackerKCF); +}; + +/** @brief GOTURN (@cite GOTURN) is kind of trackers based on Convolutional Neural Networks (CNN). While taking all advantages of CNN trackers, + * GOTURN is much faster due to offline training without online fine-tuning nature. + * GOTURN tracker addresses the problem of single target tracking: given a bounding box label of an object in the first frame of the video, + * we track that object through the rest of the video. NOTE: Current method of GOTURN does not handle occlusions; however, it is fairly + * robust to viewpoint changes, lighting changes, and deformations. + * Inputs of GOTURN are two RGB patches representing Target and Search patches resized to 227x227. + * Outputs of GOTURN are predicted bounding box coordinates, relative to Search patch coordinate system, in format X1,Y1,X2,Y2. + * Original paper is here: <http://davheld.github.io/GOTURN/GOTURN.pdf> + * As long as original authors implementation: <https://github.com/davheld/GOTURN#train-the-tracker> + * Implementation of training algorithm is placed in separately here due to 3d-party dependencies: + * <https://github.com/Auron-X/GOTURN_Training_Toolkit> + * GOTURN architecture goturn.prototxt and trained model goturn.caffemodel are accessible on opencv_extra GitHub repository. +*/ +class CV_EXPORTS TrackerGOTURN : public Tracker +{ +public: + struct CV_EXPORTS Params + { + Params(); + void read(const FileNode& /*fn*/); + void write(FileStorage& /*fs*/) const; + }; + + /** @brief Constructor + @param parameters GOTURN parameters TrackerGOTURN::Params + */ + BOILERPLATE_CODE("GOTURN", TrackerGOTURN); +}; + +/************************************ MultiTracker Class ---By Laksono Kurnianggoro---) ************************************/ +/** @brief This class is used to track multiple objects using the specified tracker algorithm. +* The MultiTracker is naive implementation of multiple object tracking. +* It process the tracked objects independently without any optimization accross the tracked objects. +*/ +class CV_EXPORTS_W MultiTracker +{ +public: + + /** + * \brief Constructor. + * In the case of trackerType is given, it will be set as the default algorithm for all trackers. + * @param trackerType the name of the tracker algorithm to be used + */ + CV_WRAP MultiTracker(const String& trackerType = ""); + + /** + * \brief Destructor + */ + ~MultiTracker(); + + /** + * \brief Add a new object to be tracked. + * The defaultAlgorithm will be used the newly added tracker. + * @param image input image + * @param boundingBox a rectangle represents ROI of the tracked object + */ + CV_WRAP bool add(const Mat& image, const Rect2d& boundingBox); + + /** + * \brief Add a new object to be tracked. + * @param trackerType the name of the tracker algorithm to be used + * @param image input image + * @param boundingBox a rectangle represents ROI of the tracked object + */ + CV_WRAP bool add(const String& trackerType, const Mat& image, const Rect2d& boundingBox); + + /** + * \brief Add a set of objects to be tracked. + * @param trackerType the name of the tracker algorithm to be used + * @param image input image + * @param boundingBox list of the tracked objects + */ + CV_WRAP bool add(const String& trackerType, const Mat& image, std::vector<Rect2d> boundingBox); + + /** + * \brief Add a set of objects to be tracked using the defaultAlgorithm tracker. + * @param image input image + * @param boundingBox list of the tracked objects + */ + CV_WRAP bool add(const Mat& image, std::vector<Rect2d> boundingBox); + + /** + * \brief Update the current tracking status. + * The result will be saved in the internal storage. + * @param image input image + */ + bool update(const Mat& image); + + //!< storage for the tracked objects, each object corresponds to one tracker algorithm. + std::vector<Rect2d> objects; + + /** + * \brief Update the current tracking status. + * @param image input image + * @param boundingBox the tracking result, represent a list of ROIs of the tracked objects. + */ + CV_WRAP bool update(const Mat& image, CV_OUT std::vector<Rect2d> & boundingBox); + +protected: + //!< storage for the tracker algorithms. + std::vector< Ptr<Tracker> > trackerList; + + //!< default algorithm for the tracking method. + String defaultAlgorithm; +}; + +class ROISelector { +public: + Rect2d select(Mat img, bool fromCenter = true); + Rect2d select(const cv::String& windowName, Mat img, bool showCrossair = true, bool fromCenter = true); + void select(const cv::String& windowName, Mat img, std::vector<Rect2d> & boundingBox, bool fromCenter = true); + + struct handlerT{ + // basic parameters + bool isDrawing; + Rect2d box; + Mat image; + + // parameters for drawing from the center + bool drawFromCenter; + Point2f center; + + // initializer list + handlerT() : isDrawing(false), drawFromCenter(true) {}; + }selectorParams; + + // to store the tracked objects + std::vector<handlerT> objects; + +private: + static void mouseHandler(int event, int x, int y, int flags, void *param); + void opencv_mouse_callback(int event, int x, int y, int, void *param); + + // save the keypressed characted + int key; +}; + +Rect2d CV_EXPORTS_W selectROI(Mat img, bool fromCenter = true); +Rect2d CV_EXPORTS_W selectROI(const cv::String& windowName, Mat img, bool showCrossair = true, bool fromCenter = true); +void CV_EXPORTS_W selectROI(const cv::String& windowName, Mat img, std::vector<Rect2d> & boundingBox, bool fromCenter = true); + + +/************************************ Multi-Tracker Classes ---By Tyan Vladimir---************************************/ + +/** @brief Base abstract class for the long-term Multi Object Trackers: + +@sa Tracker, MultiTrackerTLD +*/ +class CV_EXPORTS MultiTracker_Alt +{ +public: + /** @brief Constructor for Multitracker + */ + MultiTracker_Alt() + { + targetNum = 0; + } + + /** @brief Add a new target to a tracking-list and initialize the tracker with a know bounding box that surrounding the target + @param image The initial frame + @param boundingBox The initial boundig box of target + @param tracker_algorithm_name Multi-tracker algorithm name + + @return True if new target initialization went succesfully, false otherwise + */ + bool addTarget(const Mat& image, const Rect2d& boundingBox, String tracker_algorithm_name); + + /** @brief Update all trackers from the tracking-list, find a new most likely bounding boxes for the targets + @param image The current frame + + @return True means that all targets were located and false means that tracker couldn't locate one of the targets in + current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed + missing from the frame (say, out of sight) + */ + bool update(const Mat& image); + + /** @brief Current number of targets in tracking-list + */ + int targetNum; + + /** @brief Trackers list for Multi-Object-Tracker + */ + std::vector <Ptr<Tracker> > trackers; + + /** @brief Bounding Boxes list for Multi-Object-Tracker + */ + std::vector <Rect2d> boundingBoxes; + /** @brief List of randomly generated colors for bounding boxes display + */ + std::vector<Scalar> colors; +}; + +/** @brief Multi Object Tracker for TLD. TLD is a novel tracking framework that explicitly decomposes +the long-term tracking task into tracking, learning and detection. + +The tracker follows the object from frame to frame. The detector localizes all appearances that +have been observed so far and corrects the tracker if necessary. The learning estimates detector’s +errors and updates it to avoid these errors in the future. The implementation is based on @cite TLD . + +The Median Flow algorithm (see cv::TrackerMedianFlow) was chosen as a tracking component in this +implementation, following authors. Tracker is supposed to be able to handle rapid motions, partial +occlusions, object absence etc. + +@sa Tracker, MultiTracker, TrackerTLD +*/ +class CV_EXPORTS MultiTrackerTLD : public MultiTracker_Alt +{ +public: + /** @brief Update all trackers from the tracking-list, find a new most likely bounding boxes for the targets by + optimized update method using some techniques to speedup calculations specifically for MO TLD. The only limitation + is that all target bounding boxes should have approximately same aspect ratios. Speed boost is around 20% + + @param image The current frame. + + @return True means that all targets were located and false means that tracker couldn't locate one of the targets in + current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed + missing from the frame (say, out of sight) + */ + bool update_opt(const Mat& image); +}; + +//! @} + +} /* namespace cv */ + +#endif |