vpDot.h

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2024 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 as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 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 https://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.
 */
 
#ifndef VP_DOT_H
#define VP_DOT_H
 
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpDisplay.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpImagePoint.h>
#include <visp3/core/vpPolygon.h>
#include <visp3/core/vpRect.h>
#include <visp3/core/vpTracker.h>
 
#include <fstream>
#include <list>
#include <math.h>
#include <vector>
 
#ifdef VISP_USE_MSVC
#pragma comment(linker, "/STACK:256000000") // Increase max recursion depth
#endif
 
BEGIN_VISP_NAMESPACE
 
class VISP_EXPORT vpDot : public vpTracker
{
public:
  typedef enum
  {
    CONNEXITY_4, 
    CONNEXITY_8  
  } vpConnexityType;
 
#ifdef VISP_BUILD_DEPRECATED_FUNCTIONS
public:
  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; 
#endif
 
public:
  vpDot();
  VP_EXPLICIT vpDot(const vpImagePoint &ip);
  vpDot(const vpDot &d);
  virtual ~vpDot() VP_OVERRIDE;
 
  void display(const vpImage<unsigned char> &I, vpColor color = vpColor::red, unsigned int thickness = 1) const;
 
  inline vpColVector get_nij() const
  {
    vpColVector nij(3);
    const unsigned int index_0 = 0;
    const unsigned int index_1 = 1;
    const unsigned int index_2 = 2;
    nij[index_0] = mu20 / m00;
    nij[index_1] = mu11 / m00;
    nij[index_2] = mu02 / m00;
 
    return nij;
  }
 
  inline double getArea() const { return m00; }
 
  inline vpRect getBBox() const
  {
    vpRect bbox;
 
    bbox.setRect(m_u_min, m_v_min, (m_u_max - m_u_min) + 1, (m_v_max - m_v_min) + 1);
 
    return bbox;
  };
  inline vpImagePoint getCog() const { return m_cog; }
 
  inline std::list<vpImagePoint> getEdges() const { return m_ip_edges_list; };
 
  inline std::list<vpImagePoint> getConnexities() const { return m_ip_connexities_list; };
 
  inline double getGamma() const { return m_gamma; };
 
  double getGrayLevelPrecision() const { return m_grayLevelPrecision; }
  double getMaxDotSize() const { return m_maxDotSizePercentage; }
 
  double getMeanGrayLevel() const { return m_mean_gray_level; };
 
  vpPolygon getPolygon() const { return (vpPolygon(m_ip_edges_list)); };
 
  inline unsigned int getWidth() const { return ((m_u_max - m_u_min) + 1); };
 
  inline unsigned int getHeight() const { return ((m_v_max - m_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 &cog) { m_cog = cog; }
 
  void setComputeMoments(bool activate) { m_compute_moment = activate; }
 
  void setConnexity(const vpConnexityType &connexityType) { m_connexityType = connexityType; };
  void setMaxDotSize(double percentage);
  void setGrayLevelMin(const unsigned int &level_min) { m_gray_level_min = level_min; };
  void setGrayLevelMax(const unsigned int &level_max) { m_gray_level_max = level_max; };
  void setGrayLevelPrecision(const double &grayLevelPrecision);
 
  void setGraphics(bool activate) { m_graphics = activate; }
  void setGraphicsThickness(unsigned int thickness) { m_thickness = thickness; };
 
  void track(const vpImage<unsigned char> &I);
  void track(const vpImage<unsigned char> &I, vpImagePoint &ip);
 
  // 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);
 
#ifndef VISP_BUILD_DEPRECATED_FUNCTIONS
private:
  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; 
#endif
 
private:
  std::list<vpImagePoint> m_ip_connexities_list;
 
  std::list<vpImagePoint> m_ip_edges_list;
 
  vpConnexityType m_connexityType;
 
  vpImagePoint m_cog;
 
  // Bounding box
  unsigned int m_u_min, m_u_max, m_v_min, m_v_max;
 
  // Flag used to allow display
  bool m_graphics;
 
  unsigned int m_thickness; // Graphics thickness
 
  double m_maxDotSizePercentage;
  unsigned char m_gray_level_out;
 
  double m_mean_gray_level;      // Mean gray level of the dot
  unsigned int m_gray_level_min; // left threshold for binarization
  unsigned int m_gray_level_max; // right threshold for binarization
  double m_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 m_gamma;
  bool m_compute_moment;
  double m_nbMaxPoint;
 
  void init();
  void setGrayLevelOut();
  bool connexe(const vpImage<unsigned char> &I, unsigned int u, unsigned int v, double &mean_value,
               vpImagePoint &uv_cog, unsigned int &npoints);
  bool connexe(const vpImage<unsigned char> &I, unsigned int u, unsigned int v, double &mean_value,
               vpImagePoint &uv_cog, unsigned int &npoints, std::vector<bool> &checkTab);
  void COG(const vpImage<unsigned char> &I, double &u, double &v);
};
 
END_VISP_NAMESPACE
#endif