vpDot.h

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2017 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://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * 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 <visp3/core/vpConfig.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpDisplay.h>
#include <visp3/core/vpTracker.h>
#include <visp3/core/vpRect.h>
#include <visp3/core/vpImagePoint.h>
#include <visp3/core/vpPolygon.h>

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

#ifdef VISP_USE_MSVC
#  pragma comment(linker, "/STACK:256000000") // Increase max recursion depth
#endif

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() ;

  void display(const vpImage<unsigned char>& I, vpColor color = vpColor::red,
               unsigned int thickness=1) const;

  inline vpRect getBBox() const {
    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() const {
    return this->ip_edges_list;
  };

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

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

  vpPolygon getPolygon() const {
    return (vpPolygon(ip_edges_list));
  };

  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);
  };

  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);

  vpDot& operator =(const vpDot& d) ;
  bool operator ==(const vpDot& d) const;
  bool operator !=(const vpDot& d) const;
  friend VISP_EXPORT std::ostream& operator<< (std::ostream& os, vpDot& d);

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

  inline void setCog(const vpImagePoint &ip) {
    this->cog = ip;
  }

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

  void setGraphics(const bool activate) { graphics = activate ; }
  void setGraphicsThickness(unsigned int t) {this->thickness = t;};

  void track(const vpImage<unsigned char> & I) ;
  void track(const vpImage<unsigned char> & I, vpImagePoint &ip) ;

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 ;

  unsigned int thickness; // Graphics thickness

  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);
  static void display(const vpImage<vpRGBa>& I,const vpImagePoint &cog,
                      const std::list<vpImagePoint> &edges_list, vpColor color = vpColor::red,
                      unsigned int thickness=1);
} ;

#endif