tracking_internals.hpp

// This file is part of OpenCV project.




// It is subject to the license terms in the LICENSE file found in the top-level directory




// of this distribution and at http://opencv.org/license.html.








#ifndef OPENCV_TRACKING_DETAIL_HPP




#define OPENCV_TRACKING_DETAIL_HPP








/*





* 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





*





*/








#include "opencv2/video/detail/tracking.detail.hpp"








#include "feature.hpp"
// CvHaarEvaluator




#include "onlineBoosting.hpp"
// StrongClassifierDirectSelection








namespace

cv
{



namespace
detail {



inline
namespace
tracking {







/************************************ TrackerContribFeature Base Classes ************************************/








class
CV_EXPORTS
TrackerContribFeature
:
public
TrackerFeature



{



public:



virtual
~TrackerContribFeature();







static
Ptr<TrackerContribFeature>
create(
const
String& trackerFeatureType );







virtual
void
selection(
Mat& response,
int
npoints ) = 0;







String
getClassName()
const;







protected:



String className;


};







class
CV_EXPORTS
TrackerContribFeatureSet



{



public:







TrackerContribFeatureSet();







~TrackerContribFeatureSet();







void
extraction(
const
std::vector<Mat>& images );







void
selection();







void
removeOutliers();







bool
addTrackerFeature( String trackerFeatureType );







bool
addTrackerFeature(
Ptr<TrackerContribFeature>& feature );







const
std::vector<std::pair<String, Ptr<TrackerContribFeature> > >&
getTrackerFeature()
const;







const
std::vector<Mat>&
getResponses()
const;







private:







void
clearResponses();



bool
blockAddTrackerFeature;







std::vector<std::pair<String, Ptr<TrackerContribFeature> > > features;
//list of features




std::vector<Mat> responses;
//list of response after compute







};











/************************************ TrackerContribSampler Base Classes ************************************/








class
CV_EXPORTS
TrackerContribSamplerAlgorithm
:
public
TrackerSamplerAlgorithm



{



public:



virtual
~TrackerContribSamplerAlgorithm();







static
Ptr<TrackerContribSamplerAlgorithm>
create(
const
String& trackerSamplerType );







virtual
bool
sampling(const
Mat& image,
const
Rect& boundingBox, std::vector<Mat>& sample) CV_OVERRIDE;







String
getClassName()
const;







protected:



String className;







virtual
bool
samplingImpl(
const
Mat& image,
Rect
boundingBox, std::vector<Mat>& sample ) = 0;


};







class
CV_EXPORTS
TrackerContribSampler



{



public:







TrackerContribSampler();







~TrackerContribSampler();







void
sampling(
const
Mat& image,
Rect
boundingBox );







const
std::vector<std::pair<String, Ptr<TrackerContribSamplerAlgorithm> > >&
getSamplers()
const;







const
std::vector<Mat>&
getSamples()
const;







bool
addTrackerSamplerAlgorithm( String trackerSamplerAlgorithmType );







bool
addTrackerSamplerAlgorithm(
Ptr<TrackerContribSamplerAlgorithm>& sampler );







private:



std::vector<std::pair<String, Ptr<TrackerContribSamplerAlgorithm> > > samplers;



std::vector<Mat> samples;



bool
blockAddTrackerSampler;







void
clearSamples();


};











class
CV_EXPORTS
TrackerStateEstimatorAdaBoosting
:
public
TrackerStateEstimator



{



public:



class
CV_EXPORTS
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;







private:



bool
isTarget;



Mat
targetResponses;







};







TrackerStateEstimatorAdaBoosting(
int
numClassifer,
int
initIterations,
int
nFeatures,
Size
patchSize,
const
Rect& ROI );







~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();







protected:



Ptr<TrackerTargetState>
estimateImpl(
const
std::vector<ConfidenceMap>& confidenceMaps ) CV_OVERRIDE;



void
updateImpl( std::vector<ConfidenceMap>& confidenceMaps ) CV_OVERRIDE;







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;


};











class
CV_EXPORTS
TrackerStateEstimatorSVM
:
public
TrackerStateEstimator



{



public:



TrackerStateEstimatorSVM();



~TrackerStateEstimatorSVM();







protected:



Ptr<TrackerTargetState>
estimateImpl(
const
std::vector<ConfidenceMap>& confidenceMaps ) CV_OVERRIDE;



void
updateImpl( std::vector<ConfidenceMap>& confidenceMaps ) CV_OVERRIDE;


};















/************************************ Specific TrackerSamplerAlgorithm Classes ************************************/








class
CV_EXPORTS
TrackerContribSamplerCSC
:
public
TrackerContribSamplerAlgorithm



{



public:



enum




{



MODE_INIT_POS = 1,




MODE_INIT_NEG = 2,




MODE_TRACK_POS = 3,




MODE_TRACK_NEG = 4,




MODE_DETECT = 5




};







struct
CV_EXPORTS
Params




{



Params();



float
initInRad;




float
trackInPosRad;




float
searchWinSize;




int
initMaxNegNum;




int
trackMaxPosNum;




int
trackMaxNegNum;




};







TrackerContribSamplerCSC(
const
TrackerContribSamplerCSC::Params
&parameters =
TrackerContribSamplerCSC::Params() );







void
setMode(
int
samplingMode );







~TrackerContribSamplerCSC();







protected:







bool
samplingImpl(const
Mat& image,
Rect
boundingBox, std::vector<Mat>& sample) CV_OVERRIDE;







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


};











class
CV_EXPORTS
TrackerSamplerCS
:
public
TrackerContribSamplerAlgorithm



{



public:



enum




{



MODE_POSITIVE = 1,




MODE_NEGATIVE = 2,




MODE_CLASSIFY = 3




};







struct
CV_EXPORTS
Params




{



Params();



float
overlap;




float
searchFactor;




};



TrackerSamplerCS(
const
TrackerSamplerCS::Params
&parameters =
TrackerSamplerCS::Params() );







void
setMode(
int
samplingMode );







~TrackerSamplerCS();







bool
samplingImpl(
const
Mat& image,
Rect
boundingBox, std::vector<Mat>& sample ) CV_OVERRIDE;



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;






};







class
CV_EXPORTS
TrackerSamplerPF
:
public
TrackerContribSamplerAlgorithm



{



public:



struct
CV_EXPORTS
Params




{



Params();



int
iterationNum;




int
particlesNum;




double
alpha;




Mat_<double>
std;




};



TrackerSamplerPF(const
Mat& chosenRect,const
TrackerSamplerPF::Params
&parameters =
TrackerSamplerPF::Params());



protected:



bool
samplingImpl(
const
Mat& image,
Rect
boundingBox, std::vector<Mat>& sample ) CV_OVERRIDE;



private:



Params
params;



Ptr<MinProblemSolver>
_solver;



Ptr<MinProblemSolver::Function>
_function;


};















/************************************ Specific TrackerContribFeature Classes ************************************/








class
CV_EXPORTS
TrackerFeatureFeature2d
:
public
TrackerContribFeature



{



public:







TrackerFeatureFeature2d( String detectorType, String descriptorType );







~TrackerFeatureFeature2d() CV_OVERRIDE;







void
selection(
Mat& response,
int
npoints ) CV_OVERRIDE;







protected:







bool
computeImpl( const std::vector<Mat>& images,
Mat& response ) CV_OVERRIDE;







private:







std::vector<KeyPoint> keypoints;


};






class CV_EXPORTS
TrackerFeatureHOG
: public
TrackerContribFeature



{



public:







TrackerFeatureHOG();







~TrackerFeatureHOG() CV_OVERRIDE;







void
selection(
Mat& response,
int
npoints ) CV_OVERRIDE;







protected:







bool
computeImpl(
const
std::vector<Mat>& images,
Mat& response ) CV_OVERRIDE;






};







class
CV_EXPORTS
TrackerContribFeatureHAAR
:
public
TrackerContribFeature



{



public:



struct
CV_EXPORTS
Params




{



Params();



int
numFeatures;




Size
rectSize;




bool
isIntegral;




};







TrackerContribFeatureHAAR(
const
TrackerContribFeatureHAAR::Params
&parameters =
TrackerContribFeatureHAAR::Params() );







~TrackerContribFeatureHAAR() CV_OVERRIDE;







bool
extractSelected( const std::vector<int> selFeatures, const std::vector<Mat>& images,
Mat& response );







void
selection(
Mat& response,
int
npoints ) CV_OVERRIDE;







bool
swapFeature(
int
source,
int
target );







bool
swapFeature(
int
id,
CvHaarEvaluator::FeatureHaar& feature );







CvHaarEvaluator::FeatureHaar& getFeatureAt(
int
id
);







protected:



bool
computeImpl( const std::vector<Mat>& images,
Mat& response ) CV_OVERRIDE;







private:







Params
params;



Ptr<CvHaarEvaluator> featureEvaluator;


};






class CV_EXPORTS
TrackerFeatureLBP
: public
TrackerContribFeature



{



public:







TrackerFeatureLBP();







~TrackerFeatureLBP();







void
selection(
Mat& response,
int
npoints ) CV_OVERRIDE;







protected:







bool
computeImpl(
const
std::vector<Mat>& images,
Mat& response ) CV_OVERRIDE;






};










}}}
// namespace








#endif

// OPENCV_TRACKING_DETAIL_HPP