tracking_legacy.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) 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_LEGACY_HPP
#define OPENCV_TRACKING_LEGACY_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 "tracking_internals.hpp"
 
namespace cv {
namespace legacy {
#ifndef CV_DOXYGEN
inline namespace tracking {
#endif
using namespace cv::detail::tracking;
 
/************************************ Tracker Base Class ************************************/
 
class CV_EXPORTS_W Tracker : public virtual Algorithm
{
 public:
  Tracker();
  virtual ~Tracker() CV_OVERRIDE;
 
  CV_WRAP bool init( InputArray image, const Rect2d& boundingBox );
 
  CV_WRAP bool update( InputArray image, CV_OUT Rect2d& boundingBox );
 
  virtual void read( const FileNode& fn ) CV_OVERRIDE = 0;
  virtual void write( FileStorage& fs ) const CV_OVERRIDE = 0;
 
 protected:
 
  virtual bool initImpl( const Mat& image, const Rect2d& boundingBox ) = 0;
  virtual bool updateImpl( const Mat& image, Rect2d& boundingBox ) = 0;
 
  bool isInit;
 
  Ptr<TrackerContribFeatureSet> featureSet;
  Ptr<TrackerContribSampler> sampler;
  Ptr<TrackerModel> model;
};
 
 
/************************************ Specific Tracker Classes ************************************/
 
class CV_EXPORTS_W TrackerMIL : public cv::legacy::Tracker
{
 public:
  struct CV_EXPORTS Params : cv::TrackerMIL::Params
  {
    void read( const FileNode& fn );
    void write( FileStorage& fs ) const;
  };
 
  static Ptr<legacy::TrackerMIL> create(const TrackerMIL::Params &parameters);
 
  CV_WRAP static Ptr<legacy::TrackerMIL> create();
 
  virtual ~TrackerMIL() CV_OVERRIDE {}
};
 
class CV_EXPORTS_W TrackerBoosting : public cv::legacy::Tracker
{
 public:
  struct CV_EXPORTS Params
  {
    Params();
    int numClassifiers;  
    float samplerOverlap;  
    float samplerSearchFactor;  
    int iterationInit;  
    int featureSetNumFeatures;  
    void read( const FileNode& fn );
 
    void write( FileStorage& fs ) const;
  };
 
  static Ptr<legacy::TrackerBoosting> create(const TrackerBoosting::Params &parameters);
 
  CV_WRAP static Ptr<legacy::TrackerBoosting> create();
 
  virtual ~TrackerBoosting() CV_OVERRIDE {}
};
 
class CV_EXPORTS_W TrackerMedianFlow : public cv::legacy::Tracker
{
 public:
  struct CV_EXPORTS Params
  {
    Params(); 
    int pointsInGrid;      
    cv::Size winSize;      
    int maxLevel;          
    TermCriteria termCriteria; 
    cv::Size winSizeNCC;   
    double maxMedianLengthOfDisplacementDifference; 
 
    void read( const FileNode& /*fn*/ );
    void write( FileStorage& /*fs*/ ) const;
  };
 
  static Ptr<legacy::TrackerMedianFlow> create(const TrackerMedianFlow::Params &parameters);
 
  CV_WRAP static Ptr<legacy::TrackerMedianFlow> create();
 
  virtual ~TrackerMedianFlow() CV_OVERRIDE {}
};
 
class CV_EXPORTS_W TrackerTLD : public cv::legacy::Tracker
{
 public:
  struct CV_EXPORTS Params
  {
    Params();
    void read( const FileNode& /*fn*/ );
    void write( FileStorage& /*fs*/ ) const;
  };
 
  static Ptr<legacy::TrackerTLD> create(const TrackerTLD::Params &parameters);
 
  CV_WRAP static Ptr<legacy::TrackerTLD> create();
 
  virtual ~TrackerTLD() CV_OVERRIDE {}
};
 
class CV_EXPORTS_W TrackerKCF : public cv::legacy::Tracker
{
public:
  typedef enum cv::tracking::TrackerKCF::MODE MODE;
 
  struct CV_EXPORTS Params : cv::tracking::TrackerKCF::Params
  {
    void read(const FileNode& /*fn*/);
    void write(FileStorage& /*fs*/) const;
  };
 
  virtual void setFeatureExtractor(void(*)(const Mat, const Rect, Mat&), bool pca_func = false) = 0;
 
  static Ptr<legacy::TrackerKCF> create(const TrackerKCF::Params &parameters);
 
  CV_WRAP static Ptr<legacy::TrackerKCF> create();
 
  virtual ~TrackerKCF() CV_OVERRIDE {}
};
 
#if 0  // legacy variant is not available
class CV_EXPORTS_W TrackerGOTURN : public cv::legacy::Tracker
{
public:
  struct CV_EXPORTS Params
  {
    Params();
    void read(const FileNode& /*fn*/);
    void write(FileStorage& /*fs*/) const;
    String modelTxt;
    String modelBin;
  };
 
  static Ptr<legacy::TrackerGOTURN> create(const TrackerGOTURN::Params &parameters);
 
  CV_WRAP static Ptr<legacy::TrackerGOTURN> create();
 
  virtual ~TrackerGOTURN() CV_OVERRIDE {}
};
#endif
 
class CV_EXPORTS_W TrackerMOSSE : public cv::legacy::Tracker
{
 public:
  CV_WRAP static Ptr<legacy::TrackerMOSSE> create();
 
  virtual ~TrackerMOSSE() CV_OVERRIDE {}
};
 
 
/************************************ MultiTracker Class ---By Laksono Kurnianggoro---) ************************************/
class CV_EXPORTS_W MultiTracker : public Algorithm
{
public:
 
  CV_WRAP MultiTracker();
 
  ~MultiTracker() CV_OVERRIDE;
 
  CV_WRAP bool add(Ptr<cv::legacy::Tracker> newTracker, InputArray image, const Rect2d& boundingBox);
 
  bool add(std::vector<Ptr<legacy::Tracker> > newTrackers, InputArray image, std::vector<Rect2d> boundingBox);
 
  bool update(InputArray image);
 
  CV_WRAP bool update(InputArray image, CV_OUT std::vector<Rect2d> & boundingBox);
 
  CV_WRAP const std::vector<Rect2d>& getObjects() const;
 
  CV_WRAP static Ptr<MultiTracker> create();
 
protected:
  std::vector< Ptr<Tracker> > trackerList;
 
  std::vector<Rect2d> objects;
};
 
/************************************ Multi-Tracker Classes ---By Tyan Vladimir---************************************/
 
class CV_EXPORTS MultiTracker_Alt
{
public:
  MultiTracker_Alt()
  {
    targetNum = 0;
  }
 
  bool addTarget(InputArray image, const Rect2d& boundingBox, Ptr<legacy::Tracker> tracker_algorithm);
 
  bool update(InputArray image);
 
  int targetNum;
 
  std::vector <Ptr<Tracker> > trackers;
 
  std::vector <Rect2d> boundingBoxes;
  std::vector<Scalar> colors;
};
 
class CV_EXPORTS MultiTrackerTLD : public MultiTracker_Alt
{
public:
  bool update_opt(InputArray image);
};
 
/*********************************** CSRT ************************************/
class CV_EXPORTS_W TrackerCSRT : public cv::legacy::Tracker
{
public:
  struct CV_EXPORTS Params : cv::tracking::TrackerCSRT::Params
  {
    void read(const FileNode& /*fn*/);
 
    void write(cv::FileStorage& fs) const;
  };
 
  static Ptr<legacy::TrackerCSRT> create(const TrackerCSRT::Params &parameters);
 
  CV_WRAP static Ptr<legacy::TrackerCSRT> create();
 
  CV_WRAP virtual void setInitialMask(InputArray mask) = 0;
 
  virtual ~TrackerCSRT() CV_OVERRIDE {}
};
 
 
CV_EXPORTS_W Ptr<cv::Tracker> upgradeTrackingAPI(const Ptr<legacy::Tracker>& legacy_tracker);
 
 
#ifndef CV_DOXYGEN
}  // namespace
#endif
}}  // namespace
 
#endif // OPENCV_TRACKING_LEGACY_HPP