vpDot.h

/****************************************************************************
 *
 * $Id: vpDot.h 3853 2012-07-17 16:59:39Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2012 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Track a white dot.
 *
 * Authors:
 * Eric Marchand
 * Fabien Spindler
 *
 *****************************************************************************/

#ifndef vpDot_hh
#define vpDot_hh

#include <visp/vpImage.h>
#include <visp/vpDisplay.h>
#include <visp/vpTracker.h>
#include <visp/vpRect.h>
#include <visp/vpImagePoint.h>

#ifdef VISP_BUILD_DEPRECATED_FUNCTIONS
#  include <visp/vpList.h>
#endif

#include <math.h>
#include <fstream>
#include <list>
#include <vector>

class VISP_EXPORT vpDot : public vpTracker
{
public :
  typedef enum {
    CONNEXITY_4, 
    CONNEXITY_8 
  } vpConnexityType;

  static const unsigned int SPIRAL_SEARCH_SIZE; 
  double m00; 
  double m01; 
  double m10; 
  double m11; 
  double m20; 
  double m02; 
  double mu11;
  double mu20;
  double mu02;
  vpDot() ;
  vpDot(const vpImagePoint &ip) ;
  vpDot(const vpDot& d) ;
  virtual ~vpDot() ;

  vpDot& operator =(const vpDot& d) ;
  bool operator ==(const vpDot& d);
  bool operator !=(const vpDot& d);
  
  void initTracking(const vpImage<unsigned char> &I) ;
  void initTracking(const vpImage<unsigned char> &I, const vpImagePoint &ip);
  void initTracking(const vpImage<unsigned char> &I, const vpImagePoint &ip,
            unsigned int gray_level_min, unsigned int gray_level_max);

  void track(const vpImage<unsigned char> & I) ;
  void track(const vpImage<unsigned char> & I, vpImagePoint &ip) ;
  
  void display(const vpImage<unsigned char>& I, vpColor color = vpColor::red,
               unsigned int thickness=1);
  
  inline void setCog(const vpImagePoint &cog) {
    this->cog = cog;
  }

  void setComputeMoments(const bool activate) { compute_moment = activate; }
  
  void setConnexity(vpConnexityType connexityType) {this->connexityType = connexityType; };
  void setMaxDotSize(double percentage) ;
  void setGrayLevelMin( const unsigned int &gray_level_min ) {
    this->gray_level_min = gray_level_min;
  };
  void setGrayLevelMax( const unsigned int &gray_level_max ) {
    this->gray_level_max = gray_level_max;
  };
  void setGrayLevelPrecision( const double & grayLevelPrecision );


  void setGraphics(const bool activate) { graphics = activate ; }

  inline vpRect getBBox() {
    vpRect bbox;

    bbox.setRect(this->u_min,
         this->v_min,
         this->u_max - this->u_min + 1,
         this->v_max - this->v_min + 1);

    return (bbox);
  };
  inline vpImagePoint getCog() const {
    return cog;
  }
  
  inline std::list<vpImagePoint> getEdges() {
    return this->ip_edges_list;
  };

  inline std::list<vpImagePoint> getConnexities() {
    return this->ip_connexities_list;
  };

#ifdef VISP_BUILD_DEPRECATED_FUNCTIONS

  vp_deprecated void getEdges(std::list<vpImagePoint> &edges_list) {
    edges_list = this->ip_edges_list;
  };
#endif

  inline double getGamma() {return this->gamma;};
  double getGrayLevelPrecision() const {return grayLevelPrecision;}
  double getMaxDotSize(){
    return this->maxDotSizePercentage;
  }
  double getMeanGrayLevel() {
    return (this->mean_gray_level);
  };

  inline unsigned int getWidth() const {
    return (this->u_max - this->u_min + 1);
  };

  inline unsigned int getHeight() const {
    return (this->v_max - this->v_min + 1);
  };
  
  friend VISP_EXPORT std::ostream& operator<< (std::ostream& os, vpDot& d) {
    return (os << "(" << d.getCog() << ")" ) ;
  } ;

  void print(std::ostream& os) { os << *this << std::endl ; }

#ifdef VISP_BUILD_DEPRECATED_FUNCTIONS

  vp_deprecated void getConnexities(vpList<vpImagePoint> &connexities_list) {
    // convert a vpList in a std::list
    connexities_list.kill();
    std::list<vpImagePoint>::const_iterator it;
    for (it = ip_connexities_list.begin(); it != ip_connexities_list.end(); ++it) {
      connexities_list += *it;
    }
  };
#endif

private:
  std::list<vpImagePoint> ip_connexities_list;
  
  std::list<vpImagePoint> ip_edges_list;

  vpConnexityType connexityType;

  vpImagePoint cog;

  // Bounding box
  unsigned int u_min, u_max, v_min, v_max;

  // Flag used to allow display
  bool graphics ;

  double maxDotSizePercentage;
  unsigned char gray_level_out;
  
  double mean_gray_level; // Mean gray level of the dot
  unsigned int gray_level_min; // left threshold for binarisation
  unsigned int gray_level_max; // right threshold for binarisation
  double grayLevelPrecision;  //precision of the gray level of the dot.
  //It is a double precision float witch value is in ]0,1].
  //1 means full precision, whereas values close to 0 show a very bad precision
  double gamma ;
  bool compute_moment ;
  double nbMaxPoint;
  
  void init() ;
  void setGrayLevelOut();
  bool connexe(const vpImage<unsigned char>& I,unsigned int u,unsigned int v,
          double &mean_value, double &u_cog, double &v_cog, double &n);
  bool connexe(const vpImage<unsigned char>& I,unsigned int u,unsigned int v,
          double &mean_value, double &u_cog, double &v_cog, double &n,std::vector<bool> &checkTab);
  void COG(const vpImage<unsigned char> &I,double& u, double& v) ;
  
//Static Functions
public:
  static void display(const vpImage<unsigned char>& I,const vpImagePoint &cog, 
              const std::list<vpImagePoint> &edges_list, vpColor color = vpColor::red, 
              unsigned int thickness=1);
} ;

#endif

/*
 * Local variables:
 * c-basic-offset: 2
 * End:
 */