ViSP
keyPointSurf.cpp
1 /****************************************************************************
2  *
3  * $Id: keyPointSurf.cpp 5202 2015-01-24 09:29:06Z 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 Surf key points.
36  *
37  * Authors:
38  * Nicolas Melchior
39  * Fabien Spindler
40  *
41  *****************************************************************************/
56 #include <visp/vpDebug.h>
57 #include <visp/vpConfig.h>
58 #include <stdlib.h>
59 #include <stdio.h>
60 #include <sstream>
61 #include <iomanip>
62 #if ((defined (VISP_HAVE_X11) || defined(VISP_HAVE_GTK) || defined(VISP_HAVE_GDI)) && defined(VISP_HAVE_OPENCV_NONFREE) && (VISP_HAVE_OPENCV_VERSION < 0x030000))
63 
64 #include <visp/vpKeyPointSurf.h>
65 
66 #include <visp/vpImage.h>
67 #include <visp/vpImageIo.h>
68 #include <visp/vpImagePoint.h>
69 #include <visp/vpDisplayX.h>
70 #include <visp/vpDisplayGTK.h>
71 #include <visp/vpDisplayGDI.h>
72 
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 Tracking of Surf key-points.\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/line/image.%%04d.pgm\"\n\
104  images. \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  // Declare an image, this is a gray level image (unsigned char)
220  // it size is not defined yet, it will be defined when the image will
221  // read on the disk
224 
225  // Set the path location of the image sequence
226  dirname = vpIoTools::createFilePath(ipath, "ViSP-images/cube");
227 
228  // Build the name of the image file
229  unsigned int iter = 0; // Image number
230  std::ostringstream s;
231  s.setf(std::ios::right, std::ios::adjustfield);
232  s << "image." << std::setw(4) << std::setfill('0') << iter << ".pgm";
233  filename = vpIoTools::createFilePath(dirname, s.str());
234 
235  // Read the PGM image named "filename" on the disk, and put the
236  // bitmap into the image structure I. I is initialized to the
237  // correct size
238  //
239  // exception readPGM may throw various exception if, for example,
240  // the file does not exist, or if the memory cannot be allocated
241  try{
242  vpCTRACE << "Load: " << filename << std::endl;
243 
244  vpImageIo::read(Iref, filename) ;
245  }
246  catch(...)
247  {
248  // an exception is throwned if an exception from readPGM has been catched
249  // here this will result in the end of the program
250  // Note that another error message has been printed from readPGM
251  // to give more information about the error
252  std::cerr << std::endl
253  << "ERROR:" << std::endl;
254  std::cerr << " Cannot read " << filename << std::endl;
255  std::cerr << " Check your -i " << ipath << " option " << std::endl
256  << " or VISP_INPUT_IMAGE_PATH environment variable."
257  << std::endl;
258  exit(-1);
259  }
260 
261  // We open a window using either X11, GTK or GDI.
262 #if defined VISP_HAVE_X11
263  vpDisplayX display[2];
264 #elif defined VISP_HAVE_GTK
265  vpDisplayGTK display[2];
266 #elif defined VISP_HAVE_GDI
267  vpDisplayGDI display[2];
268 #endif
269 
270  if (opt_display) {
271  try{
272  // Display size is automatically defined by the image (I) size
273  display[0].init(Iref, 100, 100,"Display reference image") ;
274  vpDisplay::display(Iref) ;
275  vpDisplay::flush(Iref) ;
276  }
277  catch(...)
278  {
279  vpERROR_TRACE("Error while displaying the image") ;
280  exit(-1);
281  }
282  }
283 
284  vpImagePoint corners[2];
285  if (opt_display && opt_click_allowed)
286  {
287  std::cout << "Click on the top left and the bottom right corners to define the part of the image where the reference points will be computed" << std::endl;
288  for (unsigned int i=0 ; i < 2 ; i++)
289  {
290  vpDisplay::getClick(Iref, corners[i]);
291  std::cout << corners[i] << std::endl;
292  }
293  }
294  else
295  {
296  corners[0].set_ij(156,209);
297  corners[1].set_ij(272,378);
298  }
299 
300  if (opt_display)
301  {
302  //Display the rectangle which defines the part of the image where the reference points are computed.
303  vpDisplay::displayRectangle(Iref, corners[0], corners[1], vpColor::green);
304  vpDisplay::flush(Iref);
305  }
306 
307  if (opt_click_allowed)
308  {
309  std::cout << "Click on the image to continue" << std::endl;
310  vpDisplay::getClick(Iref);
311  }
312 
313  vpKeyPointSurf surf;
314  // unsigned int nbrRef;
315  unsigned int height, width;
316  height = (unsigned int)(corners[1].get_i() - corners[0].get_i());
317  width = (unsigned int)(corners[1].get_j() - corners[0].get_j());
318 
319  //Computes the reference points
320  /* nbrRef = */ surf.buildReference(Iref, corners[0], height, width);
321 
322  unsigned int nbrPair = 0;
323 
324  vpImageIo::read(Icur, filename);
325 
326  if (opt_display) {
327  try{
328  // Display size is automatically defined by the image (I) size
329  display[1].init(Icur, (int)(100+Iref.getWidth()), 100,"Display current image") ;
330  vpDisplay::display(Icur) ;
331  vpDisplay::flush(Icur) ;
332  }
333  catch(...)
334  {
335  vpERROR_TRACE("Error while displaying the image") ;
336  exit(-1);
337  }
338  }
339 
340  for (iter = 1 ; iter < 30 ; iter++)
341  {
342  std::cout <<"----------------------------------------------------------"<<std::endl;
343  // set the new image name
344  s.str("");
345  s << "image." << std::setw(4) << std::setfill('0') << iter << ".pgm";
346  filename = vpIoTools::createFilePath(dirname, s.str());
347  // read the image
348  vpImageIo::read(Icur, filename);
349  if (opt_display) {
350  // Display the image
351  vpDisplay::display(Iref) ;
352  vpDisplay::display(Icur) ;
353  }
354 
355  nbrPair = surf.matchPoint(Icur);
356  std::cout << "Number of matched point : " << nbrPair <<std::endl;
357 
358  if (opt_display)
359  {
360  // Display the matched features
361  surf.display(Iref, Icur, 7);
362  vpDisplay::displayRectangle(Iref, corners[0], corners[1], vpColor::red);
363  vpDisplay::flush(Iref) ;
364  vpDisplay::flush(Icur) ;
365  }
366  }
367  return 0;
368  }
369  catch(vpException e) {
370  std::cout << "Catch an exception: " << e << std::endl;
371  return 1;
372  }
373 }
374 
375 #else
376 int
377 main()
378 {
379 #if ( ! (defined (VISP_HAVE_X11) || defined(VISP_HAVE_GTK) || defined(VISP_HAVE_GDI)) )
380  vpERROR_TRACE("You do not have X11, GTK or GDI display functionalities...");
381 #else
382  vpERROR_TRACE("You do not have 1.1.0 <= OpenCV < 3.0.0 that contains opencv_nonfree component...");
383 #endif
384 }
385 
386 #endif
static std::string getViSPImagesDataPath()
Definition: vpIoTools.cpp:1071
double get_i() const
Definition: vpImagePoint.h:195
unsigned int getWidth() const
Definition: vpImage.h:161
#define vpERROR_TRACE
Definition: vpDebug.h:395
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:132
Define the X11 console to display images.
Definition: vpDisplayX.h:152
error that can be emited by ViSP classes.
Definition: vpException.h:76
unsigned int matchPoint(const vpImage< unsigned char > &I)
void display(const vpImage< unsigned char > &Iref, const vpImage< unsigned char > &Icurrent, unsigned int size=3)
static const vpColor green
Definition: vpColor.h:170
static void flush(const vpImage< unsigned char > &I)
Definition: vpDisplay.cpp:2232
double get_j() const
Definition: vpImagePoint.h:206
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
Definition: vpParseArgv.cpp:80
static const vpColor red
Definition: vpColor.h:167
#define vpCTRACE
Definition: vpDebug.h:341
Class that implements the SURF key points and technics thanks to OpenCV library.
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 vpDisplayGTK allows to display image using the GTK+ library version 1.2.
Definition: vpDisplayGTK.h:145
virtual void displayRectangle(const vpImagePoint &topLeft, unsigned int width, unsigned int height, const vpColor &color, bool fill=false, unsigned int thickness=1)=0
void init(vpImage< unsigned char > &I, int winx=-1, int winy=-1, const char *title=NULL)
unsigned int buildReference(const vpImage< unsigned char > &I)
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
static void read(vpImage< unsigned char > &I, const char *filename)
Definition: vpImageIo.cpp:278
void set_ij(const double ii, const double jj)
Definition: vpImagePoint.h:181