vpMbKltTracker.h

/****************************************************************************
 *
 * $Id: vpMbKltTracker.h 4119 2013-02-08 10:30:53Z fspindle $
 *
 * Copyright (C) 2005 - 2013 Inria. All rights reserved.
 *
 * This software was developed at:
 * IRISA/INRIA Rennes
 * Projet Lagadic
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * http://www.irisa.fr/lagadic
 *
 * This file is part of the ViSP toolkit
 *
 * This file may be distributed under the terms of the Q Public License
 * as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE included in the packaging of this file.
 *
 * Licensees holding valid ViSP Professional Edition licenses may
 * use this file in accordance with the ViSP Commercial License
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Contact visp@irisa.fr if any conditions of this licensing are
 * not clear to you.
 *
 * Description:
 * Model based tracker using only KLT
 *
 * Authors:
 * Romain Tallonneau
 * Aurelien Yol
 *
 *****************************************************************************/
#ifndef vpMbKltTracker_h
#define vpMbKltTracker_h

#include <visp/vpConfig.h>

#ifdef VISP_HAVE_OPENCV

#include <visp/vpMbTracker.h>
#include <visp/vpKltOpencv.h>
#include <visp/vpMbtKltPolygon.h>
#include <visp/vpMeterPixelConversion.h>
#include <visp/vpPixelMeterConversion.h>
#include <visp/vpDisplayX.h>
#include <visp/vpMbtKltXmlParser.h>
#include <visp/vpHomography.h>
#include <visp/vpRobust.h>
#include <visp/vpSubColVector.h>
#include <visp/vpSubMatrix.h>
#include <visp/vpExponentialMap.h>
#include <visp/vpMbtKltPolygon.h>

class VISP_EXPORT vpMbKltTracker: virtual public vpMbTracker
{
protected:
  IplImage* cur;
  vpHomogeneousMatrix c0Mo;
  double angleAppears;
  double angleDisappears;
  bool compute_interaction;
  bool firstInitialisation;
  unsigned int maskBorder;
  double lambda;
  unsigned int  maxIter;
  double threshold_outlier;
  double percentGood;
  bool useOgre;
  vpHomogeneousMatrix ctTc0;
  vpKltOpencv tracker;
  vpMbHiddenFaces<vpMbtKltPolygon> faces;
  bool firstTrack;
  
public:
  
            vpMbKltTracker();
  virtual   ~vpMbKltTracker();
  
  virtual void            display(const vpImage<unsigned char>& I, const vpHomogeneousMatrix &cMo,
                                  const vpCameraParameters &cam, const vpColor& col, const unsigned int thickness=1,
                                  const bool displayFullModel = false);
  virtual void            display(const vpImage<vpRGBa>& I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
                                  const vpColor& col, const unsigned int thickness=1, const bool displayFullModel = false);

protected:
  virtual void            init(const vpImage<unsigned char>& I);
  virtual void            reinit(const vpImage<unsigned char>& I);
  
public:
  virtual void            loadConfigFile(const std::string& configFile);
          void            loadConfigFile(const char* configFile);
          
  virtual inline  double  getAngleAppear() { return angleAppears; }   
  
  virtual inline  double  getAngleDisappear() { return angleDisappears; } 
    
          vpMbHiddenFaces<vpMbtKltPolygon> & getFaces() { return faces;}

  inline  CvPoint2D32f*   getKltPoints() {return tracker.getFeatures();}
  
          std::vector<vpImagePoint> getKltImagePoints();
          
          std::map<int, vpImagePoint> getKltImagePointsWithId();
          
  inline  vpKltOpencv     getKltOpencv() { return tracker; }
          
  inline  double          getLambda() {return lambda;}
  
  inline  unsigned int    getMaskBorder() { return maskBorder; }
  
  inline  unsigned int    getMaxIter() {return maxIter;}
  
  inline  int             getNbKltPoints() {return tracker.getNbFeatures();}
       
  inline  double          getThresholdAcceptation() { return threshold_outlier;}
  
          void            resetTracker();
          
  virtual inline  void    setAngleAppear(const double &a) { angleAppears = a; }   
  
  virtual inline  void    setAngleDisappear(const double &a) { angleDisappears = a; } 
  
          void            setCameraParameters(const vpCameraParameters& cam);
          
          void            setKltOpencv(const vpKltOpencv& t);
          
  inline  void            setLambda(const double lambda) {this->lambda = lambda;}
  
          void            setMaskBorder(const unsigned int &e){ maskBorder = e; }
  
  inline  void            setMaxIter(const unsigned int max) {maxIter = max;}
  
  virtual void            setOgreVisibilityTest(const bool &v);
  
  virtual void            setPose(const vpImage<unsigned char> &I, const vpHomogeneousMatrix& cdMo);
  
  inline  void            setThresholdAcceptation(const double th) {threshold_outlier = th;}
  
  virtual void            testTracking();
  virtual void            track(const vpImage<unsigned char>& I);
  
protected:
          void            computeVVS(const unsigned int &nbInfos, vpColVector &w);
          
  virtual void            initFaceFromCorners(const std::vector<vpPoint>& corners, const unsigned int indexFace = -1);
  virtual void            initCylinder(const vpPoint& , const vpPoint , const double , const unsigned int ){};
  
          void            preTracking(const vpImage<unsigned char>& I, unsigned int &nbInfos, unsigned int &nbFaceUsed);
          bool            postTracking(const vpImage<unsigned char>& I, vpColVector &w);
};

#endif
#endif // VISP_HAVE_OPENCV