Visual Servoing Platform version 3.5.0
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
115class VISP_EXPORT vpDot : public vpTracker
116{
117public:
121 typedef enum {
122 CONNEXITY_4,
124 CONNEXITY_8
126 } vpConnexityType;
127
128#ifdef VISP_BUILD_DEPRECATED_FUNCTIONS
129public:
130#else
131private:
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;
193public:
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
373private:
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
421public:
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
Implementation of column vector and the associated operations.
Definition: vpColVector.h:131
Class to define RGB colors available for display functionnalities.
Definition: vpColor.h:158
static const vpColor red
Definition: vpColor.h:217
This tracker is meant to track a dot (connected pixels with same gray level) on a vpImage.
Definition: vpDot.h:116
double mu02
Definition: vpDot.h:187
std::list< vpImagePoint > getEdges() const
Definition: vpDot.h:255
vpRect getBBox() const
Definition: vpDot.h:234
double m10
Definition: vpDot.h:149
std::list< vpImagePoint > getConnexities() const
Definition: vpDot.h:265
unsigned int getWidth() const
Definition: vpDot.h:294
double mu11
Definition: vpDot.h:177
double m01
Definition: vpDot.h:142
void setGraphics(bool activate)
Definition: vpDot.h:361
void setCog(const vpImagePoint &ip)
Definition: vpDot.h:320
void setGraphicsThickness(unsigned int t)
Definition: vpDot.h:368
double getArea() const
Definition: vpDot.h:225
double getMeanGrayLevel() const
Definition: vpDot.h:280
double mu20
Definition: vpDot.h:182
double m11
Definition: vpDot.h:156
double m02
Definition: vpDot.h:170
double getMaxDotSize() const
Definition: vpDot.h:276
void print(std::ostream &os)
Definition: vpDot.h:315
vpPolygon getPolygon() const
Definition: vpDot.h:285
void setGrayLevelMax(const unsigned int &level_max)
Definition: vpDot.h:345
void setConnexity(vpConnexityType type)
Definition: vpDot.h:342
void setGrayLevelMin(const unsigned int &level_min)
Definition: vpDot.h:344
void setComputeMoments(bool activate)
Definition: vpDot.h:337
static const unsigned int SPIRAL_SEARCH_SIZE
Definition: vpDot.h:133
double getGrayLevelPrecision() const
Definition: vpDot.h:275
double m00
Definition: vpDot.h:135
double m20
Definition: vpDot.h:163
vpColVector get_nij() const
Definition: vpDot.h:210
vpConnexityType
Definition: vpDot.h:121
double getGamma() const
Definition: vpDot.h:267
vpImagePoint getCog() const
Definition: vpDot.h:247
unsigned int getHeight() const
Definition: vpDot.h:303
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition: vpImagePoint.h:88
Defines a generic 2D polygon.
Definition: vpPolygon.h:104
Defines a rectangle in the plane.
Definition: vpRect.h:80
void setRect(double l, double t, double w, double h)
Definition: vpRect.h:334
Class that defines what is a feature generic tracker.
Definition: vpTracker.h:65
vpTracker & operator=(const vpTracker &tracker)
Copy operator.
Definition: vpTracker.cpp:53
void init()
Default initialization.
Definition: vpTracker.cpp:47