text: /*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_OBJDETECT_DBT_HPP
  #define OPENCV_OBJDETECT_DBT_HPP
  
  // After this condition removal update blacklist for bindings: modules/python/common.cmake
  #if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(__ANDROID__) || \
    (defined(__cplusplus) &&  __cplusplus > 199711L) || (defined(_MSC_VER) && _MSC_VER >= 1700)
  
  #include <vector>
  
  namespace cv
  {
  
  //! @addtogroup objdetect
  //! @{
  
  class CV_EXPORTS DetectionBasedTracker
  {
      public:
          struct CV_EXPORTS Parameters
          {
              int maxTrackLifetime;
              int minDetectionPeriod; //the minimal time between run of the big object detector (on the whole frame) in ms (1000 mean 1 sec), default=0
  
              Parameters();
          };
  
          class IDetector
          {
              public:
                  IDetector():
                      minObjSize(96, 96),
                      maxObjSize(INT_MAX, INT_MAX),
                      minNeighbours(2),
                      scaleFactor(1.1f)
                  {}
  
                  virtual void detect(const cv::Mat& image, std::vector<cv::Rect>& objects) = 0;
  
                  void setMinObjectSize(const cv::Size& min)
                  {
                      minObjSize = min;
                  }
                  void setMaxObjectSize(const cv::Size& max)
                  {
                      maxObjSize = max;
                  }
                  cv::Size getMinObjectSize() const
                  {
                      return minObjSize;
                  }
                  cv::Size getMaxObjectSize() const
                  {
                      return maxObjSize;
                  }
                  float getScaleFactor()
                  {
                      return scaleFactor;
                  }
                  void setScaleFactor(float value)
                  {
                      scaleFactor = value;
                  }
                  int getMinNeighbours()
                  {
                      return minNeighbours;
                  }
                  void setMinNeighbours(int value)
                  {
                      minNeighbours = value;
                  }
                  virtual ~IDetector() {}
  
              protected:
                  cv::Size minObjSize;
                  cv::Size maxObjSize;
                  int minNeighbours;
                  float scaleFactor;
          };
  
          DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params);
          virtual ~DetectionBasedTracker();
  
          virtual bool run();
          virtual void stop();
          virtual void resetTracking();
  
          virtual void process(const cv::Mat& imageGray);
  
          bool setParameters(const Parameters& params);
          const Parameters& getParameters() const;
  
  
          typedef std::pair<cv::Rect, int> Object;
          virtual void getObjects(std::vector<cv::Rect>& result) const;
          virtual void getObjects(std::vector<Object>& result) const;
  
          enum ObjectStatus
          {
              DETECTED_NOT_SHOWN_YET,
              DETECTED,
              DETECTED_TEMPORARY_LOST,
              WRONG_OBJECT
          };
          struct ExtObject
          {
              int id;
              cv::Rect location;
              ObjectStatus status;
              ExtObject(int _id, cv::Rect _location, ObjectStatus _status)
                  :id(_id), location(_location), status(_status)
              {
              }
          };
          virtual void getObjects(std::vector<ExtObject>& result) const;
  
  
          virtual int addObject(const cv::Rect& location); //returns id of the new object
  
      protected:
          class SeparateDetectionWork;
          cv::Ptr<SeparateDetectionWork> separateDetectionWork;
          friend void* workcycleObjectDetectorFunction(void* p);
  
          struct InnerParameters
          {
              int numLastPositionsToTrack;
              int numStepsToWaitBeforeFirstShow;
              int numStepsToTrackWithoutDetectingIfObjectHasNotBeenShown;
              int numStepsToShowWithoutDetecting;
  
              float coeffTrackingWindowSize;
              float coeffObjectSizeToTrack;
              float coeffObjectSpeedUsingInPrediction;
  
              InnerParameters();
          };
          Parameters parameters;
          InnerParameters innerParameters;
  
          struct TrackedObject
          {
              typedef std::vector<cv::Rect> PositionsVector;
  
              PositionsVector lastPositions;
  
              int numDetectedFrames;
              int numFramesNotDetected;
              int id;
  
              TrackedObject(const cv::Rect& rect):numDetectedFrames(1), numFramesNotDetected(0)
              {
                  lastPositions.push_back(rect);
                  id=getNextId();
              };
  
              static int getNextId()
              {
                  static int _id=0;
                  return _id++;
              }
          };
  
          int numTrackedSteps;
          std::vector<TrackedObject> trackedObjects;
  
          std::vector<float> weightsPositionsSmoothing;
          std::vector<float> weightsSizesSmoothing;
  
          cv::Ptr<IDetector> cascadeForTracking;
  
          void updateTrackedObjects(const std::vector<cv::Rect>& detectedObjects);
          cv::Rect calcTrackedObjectPositionToShow(int i) const;
          cv::Rect calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const;
          void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector<cv::Rect>& detectedObjectsInRegions);
  };
  
  //! @} objdetect
  
  } //end of cv namespace
  #endif
  
  #endif
  