Merge pull request #29 from nailbiter/luca

Tracking-Learning-Detection and MedianFlow

modules/tracking/CMakeLists.txt

 set(the_description "Tracking API")
-ocv_define_module(tracking opencv_imgproc opencv_optim)
+ocv_define_module(tracking opencv_imgproc opencv_optim opencv_video opencv_highgui)

modules/tracking/include/opencv2/tracking.hpp

@@ -39,8 +39,8 @@
  //
  //M*/
 
-#ifndef __OPENCV_TRACKING_HPP__
-#define __OPENCV_TRACKING_HPP__
+#ifndef __OPENCV_TRACKING_LENLEN_HPP__
+#define __OPENCV_TRACKING_LENLEN_HPP__
 
 #include "opencv2/core/cvdef.h"
 
@@ -50,5 +50,4 @@ CV_EXPORTS bool initModule_tracking(void);
 }
 
 #include "opencv2/tracking/tracker.hpp"
-
-#endif //__OPENCV_TRACKING_HPP__
+#endif //__OPENCV_TRACKING_LENLEN

modules/tracking/include/opencv2/tracking/tracker.hpp

@@ -1005,6 +1005,38 @@ class CV_EXPORTS_W TrackerBoosting : public Tracker
 
   BOILERPLATE_CODE("BOOSTING",TrackerBoosting);
 };
+
+/**
+ \brief Median Flow tracker implementation.
+Implementation of a paper "Forward-Backward Error: Automatic Detection of Tracking Failures" by Z. Kalal, K. Mikolajczyk 
+and Jiri Matas.
+ */
+class CV_EXPORTS_W TrackerMedianFlow : public Tracker
+{
+ public:
+  struct CV_EXPORTS Params
+  {
+    Params();
+    int pointsInGrid;
+    void read( const FileNode& /*fn*/ );
+    void write( FileStorage& /*fs*/ ) const;
+  };
+
+  BOILERPLATE_CODE("MEDIANFLOW",TrackerMedianFlow);
+};
+
+class CV_EXPORTS_W TrackerTLD : public Tracker
+{
+ public:
+  struct CV_EXPORTS Params
+  {
+    Params();
+    void read( const FileNode& /*fn*/ );
+    void write( FileStorage& /*fs*/ ) const;
+  };
+
+  BOILERPLATE_CODE("TLD",TrackerTLD);
+};
 } /* namespace cv */
 
 #endif

modules/tracking/samples/tracker.cpp

@@ -2,6 +2,7 @@
 #include <opencv2/tracking.hpp>
 #include <opencv2/highgui.hpp>
 #include <iostream>
+#include <cstring>
 
 using namespace std;
 using namespace cv;
@@ -15,23 +16,9 @@ static bool startSelection = false;
 static const char* keys =
 { "{@tracker_algorithm | | Tracker algorithm }"
     "{@video_name      | | video name        }"
-    "{@start_frame     |1| Start frame       }" 
+    "{@start_frame     |0| Start frame       }" 
     "{@bounding_frame  |0,0,0,0| Initial bounding frame}"};
 
-static void help()
-{
-  cout << "\nThis example shows the functionality of \"Long-term optical tracking API\""
-       "-- pause video [p] and draw a bounding box around the target to start the tracker\n"
-       "Example of <video_name> is in opencv_extra/testdata/cv/tracking/\n"
-       "Call:\n"
-       "./tracker <tracker_algorithm> <video_name> <start_frame> [<bounding_frame>]\n"
-       << endl;
-
-  cout << "\n\nHot keys: \n"
-       "\tq - quit the program\n"
-       "\tp - pause video\n";
-}
-
 static void onMouse( int event, int x, int y, int, void* )
 {
   if( !selectObject )
@@ -58,7 +45,7 @@ static void onMouse( int event, int x, int y, int, void* )
           //draw the bounding box
           Mat currentFrame;
           image.copyTo( currentFrame );
-          rectangle( currentFrame, Point( (int)boundingBox.x, (int)boundingBox.y ), Point( x, y ), Scalar( 255, 0, 0 ), 2, 1 );
+          rectangle( currentFrame, Point((int) boundingBox.x, (int)boundingBox.y ), Point( x, y ), Scalar( 255, 0, 0 ), 2, 1 );
           imshow( "Tracking API", currentFrame );
         }
         break;
@@ -66,8 +53,21 @@ static void onMouse( int event, int x, int y, int, void* )
   }
 }
 
-int main( int argc, char** argv )
+static void help()
 {
+  cout << "\nThis example shows the functionality of \"Long-term optical tracking API\""
+       "-- pause video [p] and draw a bounding box around the target to start the tracker\n"
+       "Example of <video_name> is in opencv_extra/testdata/cv/tracking/\n"
+       "Call:\n"
+       "./tracker <tracker_algorithm> <video_name> <start_frame> [<bounding_frame>]\n"
+       << endl;
+
+  cout << "\n\nHot keys: \n"
+       "\tq - quit the program\n"
+       "\tp - pause video\n";
+}
+
+int main( int argc, char** argv ){
   CommandLineParser parser( argc, argv, keys );
 
   String tracker_algorithm = parser.get<String>( 0 );
@@ -81,24 +81,19 @@ int main( int argc, char** argv )
   }
 
   int coords[4]={0,0,0,0};
-  bool initFrameWasGivenInCommandLine=false;
-  
-  do
+  bool initBoxWasGivenInCommandLine=false;
   {
       String initBoundingBox=parser.get<String>(3);
-      for(size_t pos=0,ctr=0;ctr<4;ctr++)
-	  {
-        size_t npos=initBoundingBox.find_first_of(',',pos);
-        if(npos==string::npos && ctr<3)
-		{
+      for(size_t npos=0,pos=0,ctr=0;ctr<4;ctr++){
+        npos=initBoundingBox.find_first_of(',',pos);
+        if(npos==string::npos && ctr<3){
            printf("bounding box should be given in format \"x1,y1,x2,y2\",where x's and y's are integer cordinates of opposed corners of bdd box\n");
            printf("got: %s\n",initBoundingBox.substr(pos,string::npos).c_str());
            printf("manual selection of bounding box will be employed\n");
            break;
         }
         int num=atoi(initBoundingBox.substr(pos,(ctr==3)?(string::npos):(npos-pos)).c_str());
-        if(num<=0)
-		{
+        if(num<=0){
            printf("bounding box should be given in format \"x1,y1,x2,y2\",where x's and y's are integer cordinates of opposed corners of bdd box\n");
            printf("got: %s\n",initBoundingBox.substr(pos,npos-pos).c_str());
            printf("manual selection of bounding box will be employed\n");
@@ -107,9 +102,10 @@ int main( int argc, char** argv )
         coords[ctr]=num;
         pos=npos+1;
       }
-      if(coords[0]>0 && coords[1]>0 && coords[2]>0 && coords[3]>0)
-          initFrameWasGivenInCommandLine=true;
-  } while((void)0, 0);
+      if(coords[0]>0 && coords[1]>0 && coords[2]>0 && coords[3]>0){
+          initBoxWasGivenInCommandLine=true;
+      }
+  }
 
   //open the capture
   VideoCapture cap;
@@ -141,7 +137,7 @@ int main( int argc, char** argv )
   //get the first frame
   cap >> frame;
   frame.copyTo( image );
-  if(initFrameWasGivenInCommandLine){
+  if(initBoxWasGivenInCommandLine){
       selectObject=true;
       paused=false;
       boundingBox.x = coords[0];
@@ -160,15 +156,14 @@ int main( int argc, char** argv )
   {
     if( !paused )
     {
-      cap >> frame;
-
-      if( frame.empty() )
-      {
-        break;
+      if(initialized){
+          cap >> frame;
+          if(frame.empty()){
+            break;
+          }
+          frame.copyTo( image );
       }
 
-      frame.copyTo( image );
-
       if( !initialized && selectObject )
       {
         //initializes the tracker

modules/tracking/src/TLD.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*/
+
+#include "precomp.hpp"
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/imgproc.hpp"
+#include <algorithm>
+#include <limits.h>
+
+namespace cv {namespace tld
+{
+
+//debug functions and variables
+#define ALEX_DEBUG
+#ifdef ALEX_DEBUG
+#define dfprintf(x) fprintf x
+#define dprintf(x) printf x
+#else
+#define dfprintf(x)
+#define dprintf(x)
+#endif
+#define MEASURE_TIME(a) {\
+    clock_t start;float milisec=0.0;\
+    start=clock();{a} milisec=1000.0*(clock()-start)/CLOCKS_PER_SEC;\
+    dprintf(("%-90s took %f milis\n",#a,milisec)); }
+#define HERE dprintf(("%d\n",__LINE__));fflush(stderr);
+#define START_TICK(name) { clock_t start;double milisec=0.0; start=clock();
+#define END_TICK(name) milisec=1000.0*(clock()-start)/CLOCKS_PER_SEC;\
+    dprintf(("%s took %f milis\n",name,milisec)); }
+extern Rect2d etalon;
+void myassert(const Mat& img);
+void printPatch(const Mat_<uchar>& standardPatch);
+std::string type2str(const Mat& mat);
+void drawWithRects(const Mat& img,std::vector<Rect2d>& blackOnes,Rect2d whiteOne=Rect2d(-1.0,-1.0,-1.0,-1.0));
+void drawWithRects(const Mat& img,std::vector<Rect2d>& blackOnes,std::vector<Rect2d>& whiteOnes);
+
+//aux functions and variables
+//#define CLIP(x,a,b) MIN(MAX((x),(a)),(b))
+template<typename T> inline T CLIP(T x,T a,T b){return MIN(MAX(x,a),b);}
+double overlap(const Rect2d& r1,const Rect2d& r2);
+void resample(const Mat& img,const RotatedRect& r2,Mat_<uchar>& samples);
+void resample(const Mat& img,const Rect2d& r2,Mat_<uchar>& samples);
+double variance(const Mat& img);
+double variance(Mat_<double>& intImgP,Mat_<double>& intImgP2,Rect box);
+double NCC(Mat_<uchar> patch1,Mat_<uchar> patch2);
+void getClosestN(std::vector<Rect2d>& scanGrid,Rect2d bBox,int n,std::vector<Rect2d>& res);
+double scaleAndBlur(const Mat& originalImg,int scale,Mat& scaledImg,Mat& blurredImg,Size GaussBlurKernelSize);
+unsigned int getMedian(const std::vector<unsigned int>& values, int size=-1);
+
+class TLDEnsembleClassifier{
+public:
+    TLDEnsembleClassifier(int ordinal,Size size,int measurePerClassifier);
+    void integrate(Mat_<uchar> patch,bool isPositive);
+    double posteriorProbability(const uchar* data,int rowstep)const;
+    static int getMaxOrdinal();
+private:
+    static int getGridSize();
+    inline void stepPrefSuff(std::vector<uchar>& arr,int len);
+    void preinit(int ordinal);
+    unsigned short int code(const uchar* data,int rowstep)const;
+    std::vector<unsigned int> pos,neg;
+    std::vector<uchar> x1,y1,x2,y2;
+};
+
+class TrackerProxy{
+public:
+    virtual bool init( const Mat& image, const Rect2d& boundingBox)=0;
+    virtual bool update(const Mat& image, Rect2d& boundingBox)=0;
+    virtual ~TrackerProxy(){}
+};
+
+}}

modules/tracking/src/tracker.cpp

@@ -78,7 +78,7 @@ bool Tracker::init( const Mat& image, const Rect2d& boundingBox )
   //check if the model component is initialized
   if( model == 0 )
   {
-    CV_Error( -1, "The model are not initialized" );
+    CV_Error( -1, "The model is not initialized" );
     return false;
   }
 
@@ -112,6 +112,8 @@ Ptr<Tracker> Tracker::create( const String& trackerType )
 {
   BOILERPLATE_CODE("MIL",TrackerMIL);
   BOILERPLATE_CODE("BOOSTING",TrackerBoosting);
+  BOILERPLATE_CODE("MEDIANFLOW",TrackerMedianFlow);
+  BOILERPLATE_CODE("TLD",TrackerTLD);
   return Ptr<Tracker>();
 }