tracking.hpp

/*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) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// 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/core.hpp"
#include "opencv2/imgproc.hpp"
 
namespace cv
{
 
 
enum { OPTFLOW_USE_INITIAL_FLOW     = 4,
       OPTFLOW_LK_GET_MIN_EIGENVALS = 8,
       OPTFLOW_FARNEBACK_GAUSSIAN   = 256
     };
 
CV_EXPORTS_W RotatedRect CamShift( InputArray probImage, CV_IN_OUT Rect& window,
                                   TermCriteria criteria );
CV_EXPORTS_W int meanShift( InputArray probImage, CV_IN_OUT Rect& window, TermCriteria criteria );
 
CV_EXPORTS_W int buildOpticalFlowPyramid( InputArray img, OutputArrayOfArrays pyramid,
                                          Size winSize, int maxLevel, bool withDerivatives = true,
                                          int pyrBorder = BORDER_REFLECT_101,
                                          int derivBorder = BORDER_CONSTANT,
                                          bool tryReuseInputImage = true );
 
CV_EXPORTS_W void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg,
                                        InputArray prevPts, InputOutputArray nextPts,
                                        OutputArray status, OutputArray err,
                                        Size winSize = Size(21,21), int maxLevel = 3,
                                        TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
                                        int flags = 0, double minEigThreshold = 1e-4 );
 
CV_EXPORTS_W void calcOpticalFlowFarneback( InputArray prev, InputArray next, InputOutputArray flow,
                                            double pyr_scale, int levels, int winsize,
                                            int iterations, int poly_n, double poly_sigma,
                                            int flags );
 
CV_DEPRECATED CV_EXPORTS Mat estimateRigidTransform( InputArray src, InputArray dst, bool fullAffine );
 
enum
{
    MOTION_TRANSLATION = 0,
    MOTION_EUCLIDEAN   = 1,
    MOTION_AFFINE      = 2,
    MOTION_HOMOGRAPHY  = 3
};
 
CV_EXPORTS_W double computeECC(InputArray templateImage, InputArray inputImage, InputArray inputMask = noArray());
 
CV_EXPORTS_W double findTransformECC( InputArray templateImage, InputArray inputImage,
                                      InputOutputArray warpMatrix, int motionType,
                                      TermCriteria criteria,
                                      InputArray inputMask, int gaussFiltSize);
 
CV_EXPORTS_W
double findTransformECC(InputArray templateImage, InputArray inputImage,
    InputOutputArray warpMatrix, int motionType = MOTION_AFFINE,
    TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001),
    InputArray inputMask = noArray());
 
class CV_EXPORTS_W KalmanFilter
{
public:
    CV_WRAP KalmanFilter();
    CV_WRAP KalmanFilter( int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F );
 
    void init( int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F );
 
    CV_WRAP const Mat& predict( const Mat& control = Mat() );
 
    CV_WRAP const Mat& correct( const Mat& measurement );
 
    CV_PROP_RW Mat statePre;           
    CV_PROP_RW Mat statePost;          
    CV_PROP_RW Mat transitionMatrix;   
    CV_PROP_RW Mat controlMatrix;      
    CV_PROP_RW Mat measurementMatrix;  
    CV_PROP_RW Mat processNoiseCov;    
    CV_PROP_RW Mat measurementNoiseCov;
    CV_PROP_RW Mat errorCovPre;        
    CV_PROP_RW Mat gain;               
    CV_PROP_RW Mat errorCovPost;       
 
    // temporary matrices
    Mat temp1;
    Mat temp2;
    Mat temp3;
    Mat temp4;
    Mat temp5;
};
 
 
CV_EXPORTS_W Mat readOpticalFlow( const String& path );
CV_EXPORTS_W bool writeOpticalFlow( const String& path, InputArray flow );
 
class CV_EXPORTS_W DenseOpticalFlow : public Algorithm
{
public:
    CV_WRAP virtual void calc( InputArray I0, InputArray I1, InputOutputArray flow ) = 0;
    CV_WRAP virtual void collectGarbage() = 0;
};
 
class CV_EXPORTS_W SparseOpticalFlow : public Algorithm
{
public:
    CV_WRAP virtual void calc(InputArray prevImg, InputArray nextImg,
                      InputArray prevPts, InputOutputArray nextPts,
                      OutputArray status,
                      OutputArray err = cv::noArray()) = 0;
};
 
 
class CV_EXPORTS_W FarnebackOpticalFlow : public DenseOpticalFlow
{
public:
    CV_WRAP virtual int getNumLevels() const = 0;
    CV_WRAP virtual void setNumLevels(int numLevels) = 0;
 
    CV_WRAP virtual double getPyrScale() const = 0;
    CV_WRAP virtual void setPyrScale(double pyrScale) = 0;
 
    CV_WRAP virtual bool getFastPyramids() const = 0;
    CV_WRAP virtual void setFastPyramids(bool fastPyramids) = 0;
 
    CV_WRAP virtual int getWinSize() const = 0;
    CV_WRAP virtual void setWinSize(int winSize) = 0;
 
    CV_WRAP virtual int getNumIters() const = 0;
    CV_WRAP virtual void setNumIters(int numIters) = 0;
 
    CV_WRAP virtual int getPolyN() const = 0;
    CV_WRAP virtual void setPolyN(int polyN) = 0;
 
    CV_WRAP virtual double getPolySigma() const = 0;
    CV_WRAP virtual void setPolySigma(double polySigma) = 0;
 
    CV_WRAP virtual int getFlags() const = 0;
    CV_WRAP virtual void setFlags(int flags) = 0;
 
    CV_WRAP static Ptr<FarnebackOpticalFlow> create(
            int numLevels = 5,
            double pyrScale = 0.5,
            bool fastPyramids = false,
            int winSize = 13,
            int numIters = 10,
            int polyN = 5,
            double polySigma = 1.1,
            int flags = 0);
};
 
class CV_EXPORTS_W VariationalRefinement : public DenseOpticalFlow
{
public:
    CV_WRAP virtual void calcUV(InputArray I0, InputArray I1, InputOutputArray flow_u, InputOutputArray flow_v) = 0;
 
    CV_WRAP virtual int getFixedPointIterations() const = 0;
    CV_WRAP virtual void setFixedPointIterations(int val) = 0;
 
    CV_WRAP virtual int getSorIterations() const = 0;
    CV_WRAP virtual void setSorIterations(int val) = 0;
 
    CV_WRAP virtual float getOmega() const = 0;
    CV_WRAP virtual void setOmega(float val) = 0;
 
    CV_WRAP virtual float getAlpha() const = 0;
    CV_WRAP virtual void setAlpha(float val) = 0;
 
    CV_WRAP virtual float getDelta() const = 0;
    CV_WRAP virtual void setDelta(float val) = 0;
 
    CV_WRAP virtual float getGamma() const = 0;
    CV_WRAP virtual void setGamma(float val) = 0;
 
    CV_WRAP virtual float getEpsilon() const = 0;
    CV_WRAP virtual void setEpsilon(float val) = 0;
 
    CV_WRAP static Ptr<VariationalRefinement> create();
};
 
class CV_EXPORTS_W DISOpticalFlow : public DenseOpticalFlow
{
public:
    enum
    {
        PRESET_ULTRAFAST = 0,
        PRESET_FAST = 1,
        PRESET_MEDIUM = 2
    };
 
    CV_WRAP virtual int getFinestScale() const = 0;
    CV_WRAP virtual void setFinestScale(int val) = 0;
 
    CV_WRAP virtual int getPatchSize() const = 0;
    CV_WRAP virtual void setPatchSize(int val) = 0;
 
    CV_WRAP virtual int getPatchStride() const = 0;
    CV_WRAP virtual void setPatchStride(int val) = 0;
 
    CV_WRAP virtual int getGradientDescentIterations() const = 0;
    CV_WRAP virtual void setGradientDescentIterations(int val) = 0;
 
    CV_WRAP virtual int getVariationalRefinementIterations() const = 0;
    CV_WRAP virtual void setVariationalRefinementIterations(int val) = 0;
 
    CV_WRAP virtual float getVariationalRefinementAlpha() const = 0;
    CV_WRAP virtual void setVariationalRefinementAlpha(float val) = 0;
 
    CV_WRAP virtual float getVariationalRefinementDelta() const = 0;
    CV_WRAP virtual void setVariationalRefinementDelta(float val) = 0;
 
    CV_WRAP virtual float getVariationalRefinementGamma() const = 0;
    CV_WRAP virtual void setVariationalRefinementGamma(float val) = 0;
 
    CV_WRAP virtual float getVariationalRefinementEpsilon() const = 0;
    CV_WRAP virtual void setVariationalRefinementEpsilon(float val) = 0;
 
 
    CV_WRAP virtual bool getUseMeanNormalization() const = 0;
    CV_WRAP virtual void setUseMeanNormalization(bool val) = 0;
 
    CV_WRAP virtual bool getUseSpatialPropagation() const = 0;
    CV_WRAP virtual void setUseSpatialPropagation(bool val) = 0;
 
    CV_WRAP static Ptr<DISOpticalFlow> create(int preset = DISOpticalFlow::PRESET_FAST);
};
 
class CV_EXPORTS_W SparsePyrLKOpticalFlow : public SparseOpticalFlow
{
public:
    CV_WRAP virtual Size getWinSize() const = 0;
    CV_WRAP virtual void setWinSize(Size winSize) = 0;
 
    CV_WRAP virtual int getMaxLevel() const = 0;
    CV_WRAP virtual void setMaxLevel(int maxLevel) = 0;
 
    CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
    CV_WRAP virtual void setTermCriteria(TermCriteria& crit) = 0;
 
    CV_WRAP virtual int getFlags() const = 0;
    CV_WRAP virtual void setFlags(int flags) = 0;
 
    CV_WRAP virtual double getMinEigThreshold() const = 0;
    CV_WRAP virtual void setMinEigThreshold(double minEigThreshold) = 0;
 
    CV_WRAP static Ptr<SparsePyrLKOpticalFlow> create(
            Size winSize = Size(21, 21),
            int maxLevel = 3, TermCriteria crit =
            TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
            int flags = 0,
            double minEigThreshold = 1e-4);
};
 
 
 
 
class CV_EXPORTS_W Tracker
{
protected:
    Tracker();
public:
    virtual ~Tracker();
 
    CV_WRAP virtual
    void init(InputArray image, const Rect& boundingBox) = 0;
 
    CV_WRAP virtual
    bool update(InputArray image, CV_OUT Rect& boundingBox) = 0;
};
 
 
 
class CV_EXPORTS_W TrackerMIL : public Tracker
{
protected:
    TrackerMIL();  // use ::create()
public:
    virtual ~TrackerMIL() CV_OVERRIDE;
 
    struct CV_EXPORTS_W_SIMPLE Params
    {
        CV_WRAP Params();
        //parameters for sampler
        CV_PROP_RW float samplerInitInRadius;  
        CV_PROP_RW int samplerInitMaxNegNum;  
        CV_PROP_RW float samplerSearchWinSize;  
        CV_PROP_RW float samplerTrackInRadius;  
        CV_PROP_RW int samplerTrackMaxPosNum;  
        CV_PROP_RW int samplerTrackMaxNegNum;  
        CV_PROP_RW int featureSetNumFeatures;  
    };
 
    static CV_WRAP
    Ptr<TrackerMIL> create(const TrackerMIL::Params &parameters = TrackerMIL::Params());
 
    //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
    //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
};
 
 
 
class CV_EXPORTS_W TrackerGOTURN : public Tracker
{
protected:
    TrackerGOTURN();  // use ::create()
public:
    virtual ~TrackerGOTURN() CV_OVERRIDE;
 
    struct CV_EXPORTS_W_SIMPLE Params
    {
        CV_WRAP Params();
        CV_PROP_RW std::string modelTxt;
        CV_PROP_RW std::string modelBin;
    };
 
    static CV_WRAP
    Ptr<TrackerGOTURN> create(const TrackerGOTURN::Params& parameters = TrackerGOTURN::Params());
 
    //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
    //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
};
 
class CV_EXPORTS_W TrackerDaSiamRPN : public Tracker
{
protected:
    TrackerDaSiamRPN();  // use ::create()
public:
    virtual ~TrackerDaSiamRPN() CV_OVERRIDE;
 
    struct CV_EXPORTS_W_SIMPLE Params
    {
        CV_WRAP Params();
        CV_PROP_RW std::string model;
        CV_PROP_RW std::string kernel_cls1;
        CV_PROP_RW std::string kernel_r1;
        CV_PROP_RW int backend;
        CV_PROP_RW int target;
    };
 
    static CV_WRAP
    Ptr<TrackerDaSiamRPN> create(const TrackerDaSiamRPN::Params& parameters = TrackerDaSiamRPN::Params());
 
    CV_WRAP virtual float getTrackingScore() = 0;
 
    //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
    //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
};
 
class CV_EXPORTS_W TrackerNano : public Tracker
{
protected:
    TrackerNano();  // use ::create()
public:
    virtual ~TrackerNano() CV_OVERRIDE;
 
    struct CV_EXPORTS_W_SIMPLE Params
    {
        CV_WRAP Params();
        CV_PROP_RW std::string backbone;
        CV_PROP_RW std::string neckhead;
        CV_PROP_RW int backend;
        CV_PROP_RW int target;
    };
 
    static CV_WRAP
    Ptr<TrackerNano> create(const TrackerNano::Params& parameters = TrackerNano::Params());
 
    CV_WRAP virtual float getTrackingScore() = 0;
 
    //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
    //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
};
 
class CV_EXPORTS_W TrackerVit : public Tracker
{
protected:
    TrackerVit();  // use ::create()
public:
    virtual ~TrackerVit() CV_OVERRIDE;
 
    struct CV_EXPORTS_W_SIMPLE Params
    {
        CV_WRAP Params();
        CV_PROP_RW std::string net;
        CV_PROP_RW int backend;
        CV_PROP_RW int target;
        CV_PROP_RW Scalar meanvalue;
        CV_PROP_RW Scalar stdvalue;
    };
 
    static CV_WRAP
    Ptr<TrackerVit> create(const TrackerVit::Params& parameters = TrackerVit::Params());
 
    CV_WRAP virtual float getTrackingScore() = 0;
 
    // void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
    // bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
};
 
 
} // cv
 
#endif