tracking.detail.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_VIDEO_DETAIL_TRACKING_HPP




#define OPENCV_VIDEO_DETAIL_TRACKING_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/core.hpp"








namespace

cv
{



namespace
detail {



inline
namespace
tracking {







/************************************ TrackerFeature Base Classes ************************************/








class
CV_EXPORTS
TrackerFeature



{



public:



virtual
~TrackerFeature();







void
compute(const
std::vector<Mat>& images,
Mat& response);







protected:



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


};







class
CV_EXPORTS
TrackerFeatureSet



{



public:



TrackerFeatureSet();







~TrackerFeatureSet();







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







bool
addTrackerFeature(const
Ptr<TrackerFeature>& feature);







const
std::vector<Ptr<TrackerFeature>>&
getTrackerFeatures()
const;







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







private:



void
clearResponses();



bool
blockAddTrackerFeature;







std::vector<Ptr<TrackerFeature>> features;
// list of features




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



};







/************************************ TrackerSampler Base Classes ************************************/








class
CV_EXPORTS
TrackerSamplerAlgorithm



{



public:



virtual
~TrackerSamplerAlgorithm();







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


};







class
CV_EXPORTS
TrackerSampler



{



public:



TrackerSampler();







~TrackerSampler();







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







const
std::vector<Ptr<TrackerSamplerAlgorithm>>&
getSamplers()
const;







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







bool
addTrackerSamplerAlgorithm(const
Ptr<TrackerSamplerAlgorithm>& sampler);







private:



std::vector<Ptr<TrackerSamplerAlgorithm>> samplers;



std::vector<Mat> samples;



bool
blockAddTrackerSampler;







void
clearSamples();


};







/************************************ TrackerModel Base Classes ************************************/








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







protected:



Point2f
targetPosition;



int
targetWidth;



int
targetHeight;


};







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







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







class
CV_EXPORTS
TrackerStateEstimator



{



public:



virtual
~TrackerStateEstimator();







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







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







static
Ptr<TrackerStateEstimator>
create(const
String& trackeStateEstimatorType);







String
getClassName()
const;







protected:



virtual
Ptr<TrackerTargetState>
estimateImpl(const
std::vector<ConfidenceMap>& confidenceMaps) = 0;



virtual
void
updateImpl(std::vector<ConfidenceMap>& confidenceMaps) = 0;



String className;


};







class
CV_EXPORTS
TrackerModel



{



public:



TrackerModel();







virtual
~TrackerModel();







bool
setTrackerStateEstimator(Ptr<TrackerStateEstimator>
trackerStateEstimator);







void
modelEstimation(const
std::vector<Mat>& responses);







void
modelUpdate();







bool
runStateEstimator();







void
setLastTargetState(const
Ptr<TrackerTargetState>& lastTargetState);







Ptr<TrackerTargetState>
getLastTargetState()
const;







const
std::vector<ConfidenceMap>&
getConfidenceMaps()
const;







const
ConfidenceMap&
getLastConfidenceMap()
const;







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;


};







/************************************ Specific TrackerStateEstimator Classes ************************************/








// None








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








class
CV_EXPORTS
TrackerSamplerCSC
:
public
TrackerSamplerAlgorithm



{



public:



~TrackerSamplerCSC();







enum
MODE




{



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;




};







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







void
setMode(int
samplingMode);







bool
sampling(const
Mat& image,
const
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);


};










}}}
// namespace cv::detail::tracking








#endif

// OPENCV_VIDEO_DETAIL_TRACKING_HPP