klt.hpp

/*********************************************************************
 * klt.hpp
 * jafar interface and improvements for the Birchfield implementation of the 
 * Kanade-Lucas-Tomasi tracker
 * http://www.ces.clemson.edu/~stb/klt/
 * contact : cyril.roussillon@laas.fr
 *********************************************************************/

#ifndef _KLT_HPP_
#define _KLT_HPP_

#include "klt/klt.h"
#include "image/Image.hpp"
#include "klt/compatImage.hpp"

#include "filter/observeModel.hpp"
#include "filter/predictModel.hpp"
#include "filter/kalmanFilter.hpp"



namespace jafar {
  
  namespace klt {

    
    typedef double tDate;
    
    class TrackedObject
    {
    public:
      KLT_FeatureTable ft; 
                           //  (circular buffer so that you can let the algorithm running)

      int curFrame; 

      // state
      int scope, prevScope; 
          //the barycenter

      int boundingBox[4]; 
        //bounding box of the object (x1,y1,x2,y2)

      int pos[2]; 
      //(x,y)
      
      //
      int maxDisplacement; 
         //one frame to the next, determining the
         //size of the processing area

      int maxAccel; 
        //pixels by frames^2, determining the error of the
        //kalman model (speed is constant)

      int measureConfidence; 
           //(barycenter of features representing the object)
      
      int initSpeedConfidence; 
                               // that's to say the maximum value of initial speed 
                               // (because we assume it to be 0 for the first frame)
      
      //--- kalman prediction
      int estimatedPos[2]; 
      
      int estimatedSpeed[2]; 
      
      int confidenceDist; 
   
      TrackedObject()
      {
  estimatedPos[0] = 0;
  estimatedPos[1] = 0;
  confidenceDist = 0;
  ft = NULL;
  curFrame = 0;
      }
      
      ~TrackedObject()
      {
  if (ft != NULL) KLTFreeFeatureTable(ft);
      }
      
      int calcState(KLT_FeatureList fl, bool first=false);

      void detectLandscape(KLT_FeatureList fl);
    };
    
    
    class Klt
    {
      int workingPos[2];
      int prevWorkingPos[2];
      int workingDims[2];
      int prevWorkingDims[2];
    
      //int trackingZone[4]; // = workingZone - borders
      int searchingZone[4];
      
      int securityMargin;
      
      filter::KalmanFilter *kalman; 
      tDate lastTimeStamp;
      
    public:
      
      TrackedObject object;
      
      Klt(int maxDisplacement=50, int maxAccel=50, int securityMargin=10, 
    int measureConfidence=10, int initSpeedConfidence=100):
  securityMargin(securityMargin)
      { 
  object.maxDisplacement = maxDisplacement; 
  object.maxAccel = maxAccel;
  object.measureConfidence = measureConfidence;
  object.initSpeedConfidence = initSpeedConfidence;
  kalman = NULL;
      }
      
      KLT_TrackingContext CreateTrackingContext(void)
      { return KLTCreateTrackingContext(); }

      KLT_FeatureList CreateFeatureList(int nFeatures)
      { return KLTCreateFeatureList(nFeatures); }
      
      KLT_FeatureHistory CreateFeatureHistory(int nFrames)
      { return KLTCreateFeatureHistory(nFrames); }

      KLT_FeatureTable CreateFeatureTable(int nFrames, int nFeatures)
      { return KLTCreateFeatureTable(nFrames, nFeatures); }

      // Free 
      void FreeTrackingContext(KLT_TrackingContext tc)
      { return KLTFreeTrackingContext(tc); }
      
      void FreeFeatureList(KLT_FeatureList fl)
      { return KLTFreeFeatureList(fl); }
      
      void FreeFeatureHistory(KLT_FeatureHistory fh)
      { return KLTFreeFeatureHistory(fh); }
      
      void FreeFeatureTable(KLT_FeatureTable ft)
      { return KLTFreeFeatureTable(ft); }

      // Processing 
      void SelectGoodFeatures(KLT_TrackingContext tc, 
            image::Image &jImg, KLT_FeatureList fl)
      { 
  klt::CompatTreatment treatment;
  KLT_PixelType *img = compatImage(jImg, treatment);
  KLTSelectGoodFeatures(tc, img, jImg.width(), jImg.height(), fl);
  destroyCompatImage(img, treatment);
      }
  
      void TrackFeatures(KLT_TrackingContext tc,
       image::Image &jImg1, image::Image &jImg2,
       KLT_FeatureList fl)
      { 
  klt::CompatTreatment treatment1, treatment2;
  KLT_PixelType *img1 = NULL, *img2 = NULL;
  //  if (!tc->sequentialMode) 
  img1 = compatImage(jImg1, treatment1);
  img2 = compatImage(jImg2, treatment2); 
  KLTTrackFeatures(tc, img1, img2, jImg2.width(), jImg2.height(), fl); 
  //  if (!tc->sequentialMode) 
  destroyCompatImage(img1, treatment1);
  destroyCompatImage(img2, treatment2);
      }
  
      void ReplaceLostFeatures(KLT_TrackingContext tc, 
             image::Image &jImg,
             int ncols, int nrows, KLT_FeatureList fl)
      {
  klt::CompatTreatment treatment;
  KLT_PixelType *img = compatImage(jImg, treatment); 
  KLTReplaceLostFeatures(tc, img, ncols, nrows, fl); 
  destroyCompatImage(img, treatment);
      }
      
      void SelectGoodFeaturesObject(KLT_TrackingContext tc, image::Image &jImg, 
            KLT_FeatureList fl,int zone_x=-1, int zone_y=-1, int zone_w=-1, 
            int zone_h=-1,tDate timeStamp = -1);
      void TrackFeaturesObject(KLT_TrackingContext tc,
             image::Image &jImg1, image::Image &jImg2,
             KLT_FeatureList fl, bool replace=false, tDate timeStamp = -1);
      
      // Utilities  
      int CountRemainingFeatures(KLT_FeatureList fl)
      { return KLTCountRemainingFeatures(fl); }
      
      void PrintTrackingContext(KLT_TrackingContext tc)
      { return KLTPrintTrackingContext(tc); }
      
      void ChangeTCPyramid(KLT_TrackingContext tc, int search_range)
      { return KLTChangeTCPyramid(tc, search_range); }
      
      void UpdateTCBorder(KLT_TrackingContext tc)
      { return KLTUpdateTCBorder(tc); }
        
      void StopSequentialMode(KLT_TrackingContext tc)
      { return KLTStopSequentialMode(tc); }
  
      void SetVerbosity(int verbosity)
      { return KLTSetVerbosity(verbosity); }
      
      float ComputeSmoothSigma(KLT_TrackingContext tc)
      { return _KLTComputeSmoothSigma(tc); }

      // Storing/Extracting Features 
      void StoreFeatureList(KLT_FeatureList fl, KLT_FeatureTable ft, int frame)
      { return KLTStoreFeatureList(fl, ft, frame); }
      
      void ExtractFeatureList(KLT_FeatureList fl, KLT_FeatureTable ft, int frame)
      { return KLTExtractFeatureList(fl, ft, frame); }
      
      void StoreFeatureHistory(KLT_FeatureHistory fh, KLT_FeatureTable ft, int feat)
      { return KLTStoreFeatureHistory(fh, ft, feat); }
      
      void ExtractFeatureHistory(KLT_FeatureHistory fh, KLT_FeatureTable ft, int feat)
      { return KLTExtractFeatureHistory(fh, ft, feat); }

      // Writing/Reading 
    
      void WriteFeatureListToPPM(KLT_FeatureList fl, KLT_PixelType *greyimg,
         int ncols, int nrows, char *filename)    
      { return KLTWriteFeatureListToPPM(fl, greyimg, ncols, nrows, filename); }

      void WriteImageToImg(image::Image &jGreyimg, image::Image &jRGBimg);
      void WriteFeatureListToImg(KLT_FeatureList fl, image::Image &jRGBimg);
      void WriteBordersToImg(image::Image &jRGBimg, KLT_TrackingContext tc);
      
      void WriteKalmanToImg(image::Image &jRGBimg, KLT_TrackingContext tc);
      
      void WriteFeatureList(KLT_FeatureList fl, char *filename, char *fmt)
      { return KLTWriteFeatureList(fl, filename, fmt); }
      
      void WriteFeatureHistory(KLT_FeatureHistory fh, char *filename, char *fmt)
      { return KLTWriteFeatureHistory(fh, filename, fmt); }
  
      void WriteFeatureTable(KLT_FeatureTable ft, char *filename, char *fmt)
      { return KLTWriteFeatureTable(ft, filename, fmt); }
  
      KLT_FeatureList ReadFeatureList(KLT_FeatureList fl, char *filename)
      { return KLTReadFeatureList(fl, filename); }
      
      KLT_FeatureHistory ReadFeatureHistory(KLT_FeatureHistory fh, char *filename)
      { return KLTReadFeatureHistory(fh, filename); }
      
      KLT_FeatureTable ReadFeatureTable(KLT_FeatureTable ft, char *filename)
      { return KLTReadFeatureTable(ft, filename); }
    };
    
    
  }
  
} // end namespaces

#endif