ViSP
trackMeCircle.cpp
1 /****************************************************************************
2  *
3  * $Id: trackMeCircle.cpp 5108 2015-01-05 07:48:58Z fspindle $
4  *
5  * This file is part of the ViSP software.
6  * Copyright (C) 2005 - 2014 by INRIA. All rights reserved.
7  *
8  * This software is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * ("GPL") version 2 as published by the Free Software Foundation.
11  * See the file LICENSE.txt at the root directory of this source
12  * distribution for additional information about the GNU GPL.
13  *
14  * For using ViSP with software that can not be combined with the GNU
15  * GPL, please contact INRIA about acquiring a ViSP Professional
16  * Edition License.
17  *
18  * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
19  *
20  * This software was developed at:
21  * INRIA Rennes - Bretagne Atlantique
22  * Campus Universitaire de Beaulieu
23  * 35042 Rennes Cedex
24  * France
25  * http://www.irisa.fr/lagadic
26  *
27  * If you have questions regarding the use of this file, please contact
28  * INRIA at visp@inria.fr
29  *
30  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
31  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
32  *
33  *
34  * Description:
35  * Tracking of an ellipse.
36  *
37  * Authors:
38  * Eric Marchand
39  * Fabien Spindler
40  *
41  *****************************************************************************/
54 #include <visp/vpDebug.h>
55 #include <visp/vpConfig.h>
56 
57 #include <stdlib.h>
58 #include <stdio.h>
59 #include <sstream>
60 #include <iomanip>
61 
62 #if (defined (VISP_HAVE_X11) || defined(VISP_HAVE_GTK) || defined(VISP_HAVE_GDI) || defined(VISP_HAVE_OPENCV))
63 
64 #include <visp/vpImage.h>
65 #include <visp/vpImageIo.h>
66 #include <visp/vpDisplayX.h>
67 #include <visp/vpDisplayGTK.h>
68 #include <visp/vpDisplayGDI.h>
69 #include <visp/vpDisplayOpenCV.h>
70 #include <visp/vpColor.h>
71 
72 #include <visp/vpMeEllipse.h>
73 #include <visp/vpParseArgv.h>
74 #include <visp/vpIoTools.h>
75 
76 // List of allowed command line options
77 #define GETOPTARGS "cdi:h"
78 
79 void usage(const char *name, const char *badparam, std::string ipath);
80 bool getOptions(int argc, const char **argv, std::string &ipath, bool &click_allowed, bool &display);
81 
91 void usage(const char *name, const char *badparam, std::string ipath)
92 {
93  fprintf(stdout, "\n\
94 Test auto detection of dots using vpDot2.\n\
95 \n\
96 SYNOPSIS\n\
97  %s [-i <input image path>] [-c] [-d] [-h]\n", name);
98 
99  fprintf(stdout, "\n\
100 OPTIONS: Default\n\
101  -i <input image path> %s\n\
102  Set image input path.\n\
103  From this path read \"ViSP-images/circle/circle.pgm\"\n\
104  image. \n\
105  Setting the VISP_INPUT_IMAGE_PATH environment\n\
106  variable produces the same behaviour than using\n\
107  this option.\n\
108 \n\
109  -c\n\
110  Disable the mouse click. Useful to automaze the \n\
111  execution of this program without humain intervention.\n\
112 \n\
113  -d \n\
114  Turn off the display.\n\
115 \n\
116  -h\n\
117  Print the help.\n",
118  ipath.c_str());
119 
120  if (badparam)
121  fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
122 }
136 bool getOptions(int argc, const char **argv, std::string &ipath, bool &click_allowed, bool &display)
137 {
138  const char *optarg_;
139  int c;
140  while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) {
141 
142  switch (c) {
143  case 'c': click_allowed = false; break;
144  case 'd': display = false; break;
145  case 'i': ipath = optarg_; break;
146  case 'h': usage(argv[0], NULL, ipath); return false; break;
147 
148  default:
149  usage(argv[0], optarg_, ipath);
150  return false; break;
151  }
152  }
153 
154  if ((c == 1) || (c == -1)) {
155  // standalone param or error
156  usage(argv[0], NULL, ipath);
157  std::cerr << "ERROR: " << std::endl;
158  std::cerr << " Bad argument " << optarg_ << std::endl << std::endl;
159  return false;
160  }
161 
162  return true;
163 }
164 
165 
166 int
167 main(int argc, const char ** argv)
168 {
169  try {
170  std::string env_ipath;
171  std::string opt_ipath;
172  std::string ipath;
173  std::string dirname;
174  std::string filename;
175  bool opt_click_allowed = true;
176  bool opt_display = true;
177 
178  // Get the visp-images-data package path or VISP_INPUT_IMAGE_PATH environment variable value
179  env_ipath = vpIoTools::getViSPImagesDataPath();
180 
181  // Set the default input path
182  if (! env_ipath.empty())
183  ipath = env_ipath;
184 
185  // Read the command line options
186  if (getOptions(argc, argv, opt_ipath, opt_click_allowed,
187  opt_display) == false) {
188  exit (-1);
189  }
190 
191  // Get the option values
192  if (!opt_ipath.empty())
193  ipath = opt_ipath;
194 
195  // Compare ipath and env_ipath. If they differ, we take into account
196  // the input path comming from the command line option
197  if (!opt_ipath.empty() && !env_ipath.empty()) {
198  if (ipath != env_ipath) {
199  std::cout << std::endl
200  << "WARNING: " << std::endl;
201  std::cout << " Since -i <visp image path=" << ipath << "> "
202  << " is different from VISP_IMAGE_PATH=" << env_ipath << std::endl
203  << " we skip the environment variable." << std::endl;
204  }
205  }
206 
207  // Test if an input path is set
208  if (opt_ipath.empty() && env_ipath.empty()){
209  usage(argv[0], NULL, ipath);
210  std::cerr << std::endl
211  << "ERROR:" << std::endl;
212  std::cerr << " Use -i <visp image path> option or set VISP_INPUT_IMAGE_PATH "
213  << std::endl
214  << " environment variable to specify the location of the " << std::endl
215  << " image path where test images are located." << std::endl << std::endl;
216  exit(-1);
217  }
218 
219 
220  // Declare an image, this is a gray level image (unsigned char)
221  // it size is not defined yet, it will be defined when the image will
222  // read on the disk
224 
225  // Set the path location of the image sequence
226  dirname = vpIoTools::createFilePath(ipath, "ViSP-images/circle");
227 
228  // Build the name of the image file
229  filename = vpIoTools::createFilePath(dirname, "circle.pgm");
230 
231  // Read the PGM image named "filename" on the disk, and put the
232  // bitmap into the image structure I. I is initialized to the
233  // correct size
234  //
235  // exception readPGM may throw various exception if, for example,
236  // the file does not exist, or if the memory cannot be allocated
237  try{
238  vpCTRACE << "Load: " << filename << std::endl;
239 
240  vpImageIo::read(I, filename) ;
241  }
242  catch(...)
243  {
244  // an exception is throwned if an exception from readPGM has been catched
245  // here this will result in the end of the program
246  // Note that another error message has been printed from readPGM
247  // to give more information about the error
248  std::cerr << std::endl
249  << "ERROR:" << std::endl;
250  std::cerr << " Cannot read " << filename << std::endl;
251  std::cerr << " Check your -i " << ipath << " option " << std::endl
252  << " or VISP_INPUT_IMAGE_PATH environment variable."
253  << std::endl;
254  exit(-1);
255  }
256 
257 
258  // We open a window using either X11, GTK or GDI.
259 #if defined VISP_HAVE_X11
260  vpDisplayX display;
261 #elif defined VISP_HAVE_GTK
262  vpDisplayGTK display;
263 #elif defined VISP_HAVE_GDI
264  vpDisplayGDI display;
265 #elif defined VISP_HAVE_OPENCV
266  vpDisplayOpenCV display;
267 #endif
268 
269  if (opt_display) {
270  // Display size is automatically defined by the image (I) size
271  display.init(I, 100, 100,"Display...") ;
272  // Display the image
273  // The image class has a member that specify a pointer toward
274  // the display that has been initialized in the display declaration
275  // therefore is is no longuer necessary to make a reference to the
276  // display variable.
277  vpDisplay::display(I) ;
278  vpDisplay::flush(I) ;
279  }
280 
281  vpMeEllipse E1 ;
282 
283  vpMe me ;
284  me.setRange(20) ;
285  me.setSampleStep(2) ;
286  me.setPointsToTrack(60) ;
287  me.setThreshold(15000) ;
288 
289  E1.setCircle(true) ;
290  E1.setMe(&me) ;
292  // If click is allowed, wait for a mouse click to select the points
293  // on the ellipse
294  if (opt_display && opt_click_allowed) {
295  E1.initTracking(I) ;
296  }
297  else {
298  // Create a list of points to automate the test
299  unsigned int n=5 ;
300  vpImagePoint *ip = new vpImagePoint [n];
301  ip[0].set_i( 39 ); ip[0].set_j( 136 );
302  ip[1].set_i( 42 ); ip[1].set_j( 83 );
303  ip[2].set_i( 86 ); ip[2].set_j( 55 );
304  ip[3].set_i( 132 ); ip[3].set_j( 72 );
305  ip[4].set_i( 145 ); ip[4].set_j( 134 );
306  E1.initTracking(I, n, ip) ;
307  delete [] ip ;
308  }
309 
310  if (opt_display) {
311  E1.display(I, vpColor::green) ;
312  vpDisplay::flush(I);
313  }
314 
315  vpTRACE("sample step %f ",E1.getMe()->getSampleStep()) ;
316  std::cout << "Tracking on image: " << filename << std::endl;
317  E1.track(I) ;
318  if (opt_display) {
319  vpDisplay::flush(I);
320  }
321 
322  if (opt_display && opt_click_allowed) {
323  std::cout << "A click to exit..." << std::endl;
325  }
326  std::cout <<"------------------------------------------------------------"<<std::endl;
327  return 0;
328  }
329  catch(vpException e) {
330  std::cout << "Catch an exception: " << e << std::endl;
331  return 1;
332  }
333 }
334 #else
335 int
336 main()
337 {
338  vpERROR_TRACE("You do not have X11, GTK, GDI or OpenCV display functionalities...");
339 }
340 
341 #endif
void init(vpImage< unsigned char > &I, int winx=-1, int winy=-1, const char *title=NULL)
static std::string getViSPImagesDataPath()
Definition: vpIoTools.cpp:1071
void initTracking(const vpImage< unsigned char > &I)
void setPointsToTrack(const int &n)
Definition: vpMe.h:215
#define vpERROR_TRACE
Definition: vpDebug.h:395
#define vpTRACE
Definition: vpDebug.h:418
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:132
void setSampleStep(const double &s)
Definition: vpMe.h:271
Define the X11 console to display images.
Definition: vpDisplayX.h:152
error that can be emited by ViSP classes.
Definition: vpException.h:76
Class that tracks an ellipse moving edges.
Definition: vpMeEllipse.h:142
Contains predetermined masks for sites and holds moving edges tracking parameters.
Definition: vpMe.h:70
static const vpColor green
Definition: vpColor.h:170
static void flush(const vpImage< unsigned char > &I)
Definition: vpDisplay.cpp:2232
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
Definition: vpParseArgv.cpp:80
#define vpCTRACE
Definition: vpDebug.h:341
void set_i(const double ii)
Definition: vpImagePoint.h:159
void track(const vpImage< unsigned char > &Im)
void setDisplay(vpMeSite::vpMeSiteDisplayType select)
Definition: vpMeTracker.h:108
static std::string createFilePath(const std::string &parent, const std::string child)
Definition: vpIoTools.cpp:1245
static void display(const vpImage< unsigned char > &I)
Definition: vpDisplay.cpp:210
The vpDisplayOpenCV allows to display image using the opencv library.
void display(const vpImage< unsigned char > &I, vpColor col)
vpMe * getMe()
Definition: vpMeTracker.h:149
The vpDisplayGTK allows to display image using the GTK+ library version 1.2.
Definition: vpDisplayGTK.h:145
void set_j(const double jj)
Definition: vpImagePoint.h:170
void setThreshold(const double &t)
Definition: vpMe.h:299
void setCircle(bool is_circle)
Definition: vpMeEllipse.h:185
virtual bool getClick(bool blocking=true)=0
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition: vpImagePoint.h:93
void setRange(const unsigned int &r)
Definition: vpMe.h:229
void setMe(vpMe *p_me)
Definition: vpMeTracker.h:142
static void read(vpImage< unsigned char > &I, const char *filename)
Definition: vpImageIo.cpp:278
double getSampleStep() const
Definition: vpMe.h:278