Visual Servoing Platform  version 3.4.1 under development (2021-04-17)
vpDot.h
1 /****************************************************************************
2  *
3  * ViSP, open source Visual Servoing Platform software.
4  * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5  *
6  * This software is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  * See the file LICENSE.txt at the root directory of this source
11  * distribution for additional information about the GNU GPL.
12  *
13  * For using ViSP with software that can not be combined with the GNU
14  * GPL, please contact Inria about acquiring a ViSP Professional
15  * Edition License.
16  *
17  * See http://visp.inria.fr for more information.
18  *
19  * This software was developed at:
20  * Inria Rennes - Bretagne Atlantique
21  * Campus Universitaire de Beaulieu
22  * 35042 Rennes Cedex
23  * France
24  *
25  * If you have questions regarding the use of this file, please contact
26  * Inria at visp@inria.fr
27  *
28  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30  *
31  * Description:
32  * Track a white dot.
33  *
34  * Authors:
35  * Eric Marchand
36  * Fabien Spindler
37  *
38  *****************************************************************************/
39 
45 #ifndef vpDot_hh
46 #define vpDot_hh
47 
48 #include <visp3/core/vpConfig.h>
49 #include <visp3/core/vpDisplay.h>
50 #include <visp3/core/vpImage.h>
51 #include <visp3/core/vpImagePoint.h>
52 #include <visp3/core/vpPolygon.h>
53 #include <visp3/core/vpRect.h>
54 #include <visp3/core/vpTracker.h>
55 
56 #include <fstream>
57 #include <list>
58 #include <math.h>
59 #include <vector>
60 
61 #ifdef VISP_USE_MSVC
62 #pragma comment(linker, "/STACK:256000000") // Increase max recursion depth
63 #endif
64 
115 class VISP_EXPORT vpDot : public vpTracker
116 {
117 public:
121  typedef enum {
122  CONNEXITY_4,
124  CONNEXITY_8
126  } vpConnexityType;
127 
128 #ifdef VISP_BUILD_DEPRECATED_FUNCTIONS
129 public:
130 #else
131 private:
132 #endif
133  static const unsigned int SPIRAL_SEARCH_SIZE;
135  double m00;
142  double m01;
149  double m10;
156  double m11;
163  double m20;
170  double m02;
177  double mu11;
182  double mu20;
187  double mu02;
193 public:
194  vpDot();
195  explicit vpDot(const vpImagePoint &ip);
196  vpDot(const vpDot &d);
197  virtual ~vpDot();
198 
199  void display(const vpImage<unsigned char> &I, vpColor color = vpColor::red, unsigned int thickness = 1) const;
200 
210  inline vpColVector get_nij() const
211  {
212  vpColVector nij(3);
213  nij[0] = mu20 / m00;
214  nij[1] = mu11 / m00;
215  nij[2] = mu02 / m00;
216 
217  return nij;
218  }
219 
225  inline double getArea() const { return m00; }
226 
234  inline vpRect getBBox() const
235  {
236  vpRect bbox;
237 
238  bbox.setRect(this->u_min, this->v_min, this->u_max - this->u_min + 1, this->v_max - this->v_min + 1);
239 
240  return (bbox);
241  };
247  inline vpImagePoint getCog() const { return cog; }
248 
255  inline std::list<vpImagePoint> getEdges() const { return this->ip_edges_list; };
256 
265  inline std::list<vpImagePoint> getConnexities() const { return this->ip_connexities_list; };
266 
267  inline double getGamma() const { return this->gamma; };
275  double getGrayLevelPrecision() const { return grayLevelPrecision; }
276  double getMaxDotSize() const { return this->maxDotSizePercentage; }
280  double getMeanGrayLevel() const { return (this->mean_gray_level); };
281 
285  vpPolygon getPolygon() const { return (vpPolygon(ip_edges_list)); };
286 
294  inline unsigned int getWidth() const { return (this->u_max - this->u_min + 1); };
295 
303  inline unsigned int getHeight() const { return (this->v_max - this->v_min + 1); };
304 
305  void initTracking(const vpImage<unsigned char> &I);
306  void initTracking(const vpImage<unsigned char> &I, const vpImagePoint &ip);
307  void initTracking(const vpImage<unsigned char> &I, const vpImagePoint &ip, unsigned int gray_level_min,
308  unsigned int gray_level_max);
309 
310  vpDot &operator=(const vpDot &d);
311  bool operator==(const vpDot &d) const;
312  bool operator!=(const vpDot &d) const;
313  friend VISP_EXPORT std::ostream &operator<<(std::ostream &os, vpDot &d);
314 
315  void print(std::ostream &os) { os << *this << std::endl; }
316 
320  inline void setCog(const vpImagePoint &ip) { this->cog = ip; }
321 
337  void setComputeMoments(bool activate) { compute_moment = activate; }
338 
342  void setConnexity(vpConnexityType type) { this->connexityType = type; };
343  void setMaxDotSize(double percentage);
344  void setGrayLevelMin(const unsigned int &level_min) { this->gray_level_min = level_min; };
345  void setGrayLevelMax(const unsigned int &level_max) { this->gray_level_max = level_max; };
346  void setGrayLevelPrecision(const double &grayLevelPrecision);
347 
361  void setGraphics(bool activate) { graphics = activate; }
368  void setGraphicsThickness(unsigned int t) { this->thickness = t; };
369 
370  void track(const vpImage<unsigned char> &I);
371  void track(const vpImage<unsigned char> &I, vpImagePoint &ip);
372 
373 private:
375  std::list<vpImagePoint> ip_connexities_list;
376 
378  std::list<vpImagePoint> ip_edges_list;
379 
384  vpConnexityType connexityType;
385 
387  vpImagePoint cog;
388 
389  // Bounding box
390  unsigned int u_min, u_max, v_min, v_max;
391 
392  // Flag used to allow display
393  bool graphics;
394 
395  unsigned int thickness; // Graphics thickness
396 
397  double maxDotSizePercentage;
398  unsigned char gray_level_out;
399 
400  double mean_gray_level; // Mean gray level of the dot
401  unsigned int gray_level_min; // left threshold for binarisation
402  unsigned int gray_level_max; // right threshold for binarisation
403  double grayLevelPrecision; // precision of the gray level of the dot.
404  // It is a double precision float witch value is in ]0,1].
405  // 1 means full precision, whereas values close to 0 show a very bad
406  // precision
407  double gamma;
409  bool compute_moment;
410  double nbMaxPoint;
411 
412  void init();
413  void setGrayLevelOut();
414  bool connexe(const vpImage<unsigned char> &I, unsigned int u, unsigned int v, double &mean_value, double &u_cog,
415  double &v_cog, double &n);
416  bool connexe(const vpImage<unsigned char> &I, unsigned int u, unsigned int v, double &mean_value, double &u_cog,
417  double &v_cog, double &n, std::vector<bool> &checkTab);
418  void COG(const vpImage<unsigned char> &I, double &u, double &v);
419 
420  // Static Functions
421 public:
422  static void display(const vpImage<unsigned char> &I, const vpImagePoint &cog,
423  const std::list<vpImagePoint> &edges_list, vpColor color = vpColor::red,
424  unsigned int thickness = 1);
425  static void display(const vpImage<vpRGBa> &I, const vpImagePoint &cog, const std::list<vpImagePoint> &edges_list,
426  vpColor color = vpColor::red, unsigned int thickness = 1);
427 };
428 
429 #endif
vpTracker & operator=(const vpTracker &tracker)
Copy operator.
Definition: vpTracker.cpp:53
double mu20
Definition: vpDot.h:182
void setConnexity(vpConnexityType type)
Definition: vpDot.h:342
double m10
Definition: vpDot.h:149
Class to define RGB colors available for display functionnalities.
Definition: vpColor.h:157
void setComputeMoments(bool activate)
Definition: vpDot.h:337
double getGrayLevelPrecision() const
Definition: vpDot.h:275
void print(std::ostream &os)
Definition: vpDot.h:315
void setGrayLevelMin(const unsigned int &level_min)
Definition: vpDot.h:344
double m00
Definition: vpDot.h:135
vpConnexityType
Definition: vpDot.h:121
double mu11
Definition: vpDot.h:177
double getMeanGrayLevel() const
Definition: vpDot.h:280
double mu02
Definition: vpDot.h:187
vpPolygon getPolygon() const
Definition: vpDot.h:285
static const unsigned int SPIRAL_SEARCH_SIZE
Definition: vpDot.h:133
double m20
Definition: vpDot.h:163
double m11
Definition: vpDot.h:156
static const vpColor red
Definition: vpColor.h:217
Class that defines what is a feature generic tracker.
Definition: vpTracker.h:64
Defines a generic 2D polygon.
Definition: vpPolygon.h:103
double m01
Definition: vpDot.h:142
vpImagePoint getCog() const
Definition: vpDot.h:247
vpRect getBBox() const
Definition: vpDot.h:234
void setGraphicsThickness(unsigned int t)
Definition: vpDot.h:368
unsigned int getHeight() const
Definition: vpDot.h:303
double m02
Definition: vpDot.h:170
double getArea() const
Definition: vpDot.h:225
Implementation of column vector and the associated operations.
Definition: vpColVector.h:130
double getGamma() const
Definition: vpDot.h:267
void setGrayLevelMax(const unsigned int &level_max)
Definition: vpDot.h:345
void init()
Default initialization.
Definition: vpTracker.cpp:47
This tracker is meant to track a dot (connected pixels with same gray level) on a vpImage...
Definition: vpDot.h:115
Defines a rectangle in the plane.
Definition: vpRect.h:79
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition: vpImagePoint.h:87
unsigned int getWidth() const
Definition: vpDot.h:294
void setGraphics(bool activate)
Definition: vpDot.h:361
vpColVector get_nij() const
Definition: vpDot.h:210
std::list< vpImagePoint > getEdges() const
Definition: vpDot.h:255
void setRect(double l, double t, double w, double h)
Definition: vpRect.h:334
std::list< vpImagePoint > getConnexities() const
Definition: vpDot.h:265
void setCog(const vpImagePoint &ip)
Definition: vpDot.h:320
double getMaxDotSize() const
Definition: vpDot.h:276