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