ViSP
 All Classes Functions Variables Enumerations Enumerator Friends Groups Pages
displayOpenCV.cpp
1 /****************************************************************************
2  *
3  * $Id: displayOpenCV.cpp 4323 2013-07-18 09:24:01Z fspindle $
4  *
5  * This file is part of the ViSP software.
6  * Copyright (C) 2005 - 2013 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  * Read an image on the disk and display it using OpenCV.
36  *
37  * Authors:
38  * Nicolas Melchior
39  *
40  *****************************************************************************/
50 #include <visp/vpDebug.h>
51 #include <visp/vpConfig.h>
52 #include <stdlib.h>
53 #ifdef VISP_HAVE_OPENCV
54 
55 #include <visp/vpImage.h>
56 #include <visp/vpImageIo.h>
57 #include <visp/vpDisplayOpenCV.h>
58 #include <visp/vpParseArgv.h>
59 #include <visp/vpIoTools.h>
60 
61 #include <visp/vpTime.h>
62 
72 // List of allowed command line options
73 #define GETOPTARGS "cdi:o:p:h"
74 
86 void usage(const char *name, const char *badparam, std::string ipath,
87  std::string opath, std::string user)
88 {
89  fprintf(stdout, "\n\
90 Read an image on the disk, display it using OpenCV, display some\n\
91 features (line, circle, caracters) in overlay and finaly write \n\
92 the image and the overlayed features in an image on the disk.\n\
93 \n\
94 SYNOPSIS\n\
95  %s [-i <input image path>] [-o <output image path>]\n\
96  [-c] [-d] [-h]\n \
97 ", 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/Klimt/Klimt.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  -o <output image path> %s\n\
110  Set image output path.\n\
111  From this directory, creates the \"%s\"\n\
112  subdirectory depending on the username, where \n\
113  Klimt_grey.overlay.ppm output image is written.\n\
114 \n\
115  -c\n\
116  Disable the mouse click. Useful to automate the \n\
117  execution of this program without humain intervention.\n\
118 \n\
119  -d \n\
120  Disable the image display. This can be useful \n\
121  for automatic tests using crontab under Unix or \n\
122  using the task manager under Windows.\n\
123 \n\
124  -h\n\
125  Print the help.\n\n",
126  ipath.c_str(), opath.c_str(), user.c_str());
127 
128  if (badparam) {
129  fprintf(stderr, "ERROR: \n" );
130  fprintf(stderr, "\nBad parameter [%s]\n", badparam);
131  }
132 
133 }
134 
153 bool getOptions(int argc, const char **argv,
154  std::string &ipath, std::string &opath, bool &click_allowed,
155  std::string user, bool &display)
156 {
157  const char *optarg;
158  int c;
159  while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg)) > 1) {
160 
161  switch (c) {
162  case 'c': click_allowed = false; break;
163  case 'd': display = false; break;
164  case 'i': ipath = optarg; break;
165  case 'o': opath = optarg; break;
166  case 'h': usage(argv[0], NULL, ipath, opath, user); return false; break;
167 
168  default:
169  usage(argv[0], optarg, ipath, opath, user); return false; break;
170  }
171  }
172 
173  if ((c == 1) || (c == -1)) {
174  // standalone param or error
175  usage(argv[0], NULL, ipath, opath, user);
176  std::cerr << "ERROR: " << std::endl;
177  std::cerr << " Bad argument " << optarg << std::endl << std::endl;
178  return false;
179  }
180 
181  return true;
182 }
183 
184 int
185 main(int argc, const char ** argv)
186 {
187  std::string env_ipath;
188  std::string opt_ipath;
189  std::string opt_opath;
190  std::string ipath;
191  std::string opath;
192  std::string filename;
193  std::string username;
194  bool opt_click_allowed = true;
195  bool opt_display = true;
196 
197  // Get the VISP_IMAGE_PATH environment variable value
198  char *ptenv = getenv("VISP_INPUT_IMAGE_PATH");
199  if (ptenv != NULL)
200  env_ipath = ptenv;
201  // std::cout << "env_ipath: " << env_ipath << std::endl;
202 
203  // Set the default input path
204  if (! env_ipath.empty())
205  ipath = env_ipath;
206 
207  // Set the default output path
208 #ifdef UNIX
209  opt_opath = "/tmp";
210 #elif WIN32
211  opt_opath = "C:\\temp";
212 #endif
213 
214  // Get the user login name
215  vpIoTools::getUserName(username);
216 
217  // Read the command line options
218  if (getOptions(argc, argv, opt_ipath, opt_opath,
219  opt_click_allowed, username, opt_display) == false) {
220  exit (-1);
221  }
222 
223  // Get the option values
224  if (!opt_ipath.empty())
225  ipath = opt_ipath;
226  if (!opt_opath.empty())
227  opath = opt_opath;
228 
229  // Append to the output path string, the login name of the user
230  std::string odirname = opath + vpIoTools::path("/") + username;
231 
232  // Test if the output path exist. If no try to create it
233  if (vpIoTools::checkDirectory(odirname) == false) {
234  try {
235  // Create the dirname
236  vpIoTools::makeDirectory(odirname);
237  }
238  catch (...) {
239  usage(argv[0], NULL, ipath, opath, username);
240  std::cerr << std::endl
241  << "ERROR:" << std::endl;
242  std::cerr << " Cannot create " << odirname << std::endl;
243  std::cerr << " Check your -o " << opath << " option " << std::endl;
244  exit(-1);
245  }
246  }
247 
248  // Compare ipath and env_ipath. If they differ, we take into account
249  // the input path comming from the command line option
250  if (!opt_ipath.empty() && !env_ipath.empty()) {
251  if (ipath != env_ipath) {
252  std::cout << std::endl
253  << "WARNING: " << std::endl;
254  std::cout << " Since -i <visp image path=" << ipath << "> "
255  << " is different from VISP_IMAGE_PATH=" << env_ipath << std::endl
256  << " we skip the environment variable." << std::endl;
257  }
258  }
259 
260  // Test if an input path is set
261  if (opt_ipath.empty() && env_ipath.empty()){
262  usage(argv[0], NULL, ipath, opath, username);
263  std::cerr << std::endl
264  << "ERROR:" << std::endl;
265  std::cerr << " Use -i <visp image path> option or set VISP_INPUT_IMAGE_PATH "
266  << std::endl
267  << " environment variable to specify the location of the " << std::endl
268  << " image path where test images are located." << std::endl << std::endl;
269  exit(-1);
270  }
271 
272  // Create a grey level image
274  vpImagePoint ip, ip1, ip2;
275 
276  // Load a grey image from the disk
277  filename = ipath + vpIoTools::path("/ViSP-images/Klimt/Klimt.pgm");
278  try {
279  vpImageIo::read(I, filename) ;
280  }
281  catch (...) {
282  return -1;
283  }
284 
285  // Create a display using OpenCV
286  vpDisplayOpenCV display;
287 
288  if (opt_display) {
289  // For this grey level image, open a X11 display at position 100,100
290  // in the screen, and with title "X11 display"
291  display.init(I, 100, 100, "OpenCV display") ;
292 
293  // Display the image
294  vpDisplay::display(I) ;
295 
296  // Display in overlay a red cross at position 10,10 in the
297  // image. The lines are 10 pixels long
298  ip.set_i( 100 );
299  ip.set_j( 10 );
300 
302 
303  // Display in overlay horizontal red lines
304  for (unsigned i=0 ; i < I.getHeight() ; i+=20) {
305  ip1.set_i( i );
306  ip1.set_j( 0 );
307  ip2.set_i( i );
308  ip2.set_j( I.getWidth() );
309  vpDisplay::displayLine(I, ip1, ip2, vpColor::red) ;
310  }
311 
312  // Display a ligne in the diagonal
313  ip1.set_i( -10 );
314  ip1.set_j( -10 );
315  ip2.set_i( I.getHeight() + 10 );
316  ip2.set_j( I.getWidth() + 10 );
317 
318  vpDisplay::displayLine(I, ip1, ip2, vpColor::red) ;
319 
320  // Display in overlay vertical green dot lines
321  for (unsigned i=0 ; i < I.getWidth() ; i+=20) {
322  ip1.set_i( 0 );
323  ip1.set_j( i );
324  ip2.set_i( I.getWidth() );
325  ip2.set_j( i );
327  }
328 
329  // Display a rectangle
330  ip.set_i( I.getHeight() - 45 );
331  ip.set_j( -10 );
333 
334  // Display in overlay a blue arrow
335  ip1.set_i( 0 );
336  ip1.set_j( 0 );
337  ip2.set_i( 100 );
338  ip2.set_j( 100 );
339  vpDisplay::displayArrow(I, ip1, ip2, vpColor::blue) ;
340 
341  // Display in overlay some circles. The position of the center is 200, 200
342  // the radius is increased by 20 pixels for each circle
343 
344  for (unsigned int i=0 ; i < 100 ; i+=20) {
345  ip.set_i( 80 );
346  ip.set_j( 80 );
348  }
349 
350  ip.set_i( -10 );
351  ip.set_j( 300 );
353 
354  // Display in overlay a yellow string
355  ip.set_i( 85 );
356  ip.set_j( 100 );
358  "ViSP is a marvelous software",
359  vpColor::yellow) ;
360  //Flush the display
361  vpDisplay::flush(I);
362 
363  // Create a color image
364  vpImage<vpRGBa> Ioverlay ;
365  // Updates the color image with the original loaded image and the overlay
366  vpDisplay::getImage(I, Ioverlay) ;
367 
368  // Write the color image on the disk
369  filename = odirname + vpIoTools::path("/Klimt_grey.overlay.ppm");
370  vpImageIo::write(Ioverlay, filename) ;
371 
372  // If click is allowed, wait for a mouse click to close the display
373  if (opt_click_allowed) {
374  std::cout << "\nA click to close the windows..." << std::endl;
375  // Wait for a blocking mouse click
377  }
378 
379  // Close the display
380  vpDisplay::close(I);
381  }
382 
383  // Create a color image
384  vpImage<vpRGBa> Irgba ;
385 
386  // Load a grey image from the disk and convert it to a color image
387  filename = ipath + vpIoTools::path("/ViSP-images/Klimt/Klimt.pgm");
388  try {
389  vpImageIo::read(Irgba, filename) ;
390  }
391  catch (...) {
392  return -1;
393  }
394 
395  // Create a new display
396  vpDisplayOpenCV displayRGBa;
397 
398  if (opt_display) {
399  // For this color image, open a display at position 100,100
400  // in the screen, and with title "OpenCV color display"
401  displayRGBa.init(Irgba, 100, 100, "OpenCV color display");
402 
403  // Display the color image
404  vpDisplay::display(Irgba) ;
405  vpDisplay::flush(Irgba) ;
406 
407  // If click is allowed, wait for a blocking mouse click to display a cross
408  // at the clicked pixel position
409  if (opt_click_allowed) {
410  std::cout << "\nA click to display a cross..." << std::endl;
411  // Blocking wait for a click. Get the position of the selected pixel
412  // (i correspond to the row and j to the column coordinates in the image)
413  vpDisplay::getClick(Irgba, ip);
414  // Display a red cross on the click pixel position
415  std::cout << "Cross position: " << ip << std::endl;
416  vpDisplay::displayCross(Irgba, ip, 15, vpColor::red);
417  }
418  else {
419  ip.set_i( 10 );
420  ip.set_j( 20 );
421  // Display a red cross at position i, j (i correspond to the row
422  // and j to the column coordinates in the image)
423  std::cout << "Cross position: " << ip << std::endl;
424  vpDisplay::displayCross(Irgba, ip, 15, vpColor::red);
425 
426  }
427  // Flush the display. Sometimes the display content is
428  // bufferized. Force to display the content that has been bufferized.
429  vpDisplay::flush(Irgba);
430 
431  // If click is allowed, wait for a blocking mouse click to exit.
432  if (opt_click_allowed) {
433  std::cout << "\nA click to exit the program..." << std::endl;
434  vpDisplay::getClick(Irgba) ;
435  std::cout << "Bye" << std::endl;
436  }
437  }
438 }
439 #else
440 int
441 main()
442 {
443  vpERROR_TRACE("You do not have OpenCV functionalities to display images...");
444 }
445 
446 #endif
447 
void set_j(const double j)
Definition: vpImagePoint.h:156
virtual void displayCircle(const vpImagePoint &center, unsigned int radius, const vpColor &color, bool fill=false, unsigned int thickness=1)=0
static void write(const vpImage< unsigned char > &I, const char *filename)
Definition: vpImageIo.cpp:442
void init(vpImage< unsigned char > &I, int winx=-1, int winy=-1, const char *title=NULL)
virtual void displayArrow(const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color=vpColor::white, unsigned int w=4, unsigned int h=2, unsigned int thickness=1)=0
static bool checkDirectory(const char *dirname)
Definition: vpIoTools.cpp:335
static void close(vpImage< unsigned char > &I)
Definition: vpDisplay.cpp:2028
unsigned int getWidth() const
Definition: vpImage.h:159
#define vpERROR_TRACE
Definition: vpDebug.h:379
void set_i(const double i)
Definition: vpImagePoint.h:145
static std::string path(const char *pathname)
Definition: vpIoTools.cpp:715
static const vpColor green
Definition: vpColor.h:170
static void flush(const vpImage< unsigned char > &I)
Definition: vpDisplay.cpp:1991
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
Definition: vpParseArgv.cpp:79
static const vpColor red
Definition: vpColor.h:167
static const vpColor orange
Definition: vpColor.h:177
static void makeDirectory(const char *dirname)
Definition: vpIoTools.cpp:404
static void display(const vpImage< unsigned char > &I)
Definition: vpDisplay.cpp:203
The vpDisplayOpenCV allows to display image using the opencv library.
virtual void displayCross(const vpImagePoint &ip, unsigned int size, const vpColor &color, unsigned int thickness=1)=0
static std::string getUserName()
Definition: vpIoTools.cpp:140
virtual void displayRectangle(const vpImagePoint &topLeft, unsigned int width, unsigned int height, const vpColor &color, bool fill=false, unsigned int thickness=1)=0
static void getImage(const vpImage< unsigned char > &Is, vpImage< vpRGBa > &Id)
Definition: vpDisplay.cpp:321
virtual void displayDotLine(const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color, unsigned int thickness=1)=0
virtual void displayCharString(const vpImagePoint &ip, const char *text, const vpColor &color=vpColor::green)=0
unsigned int getHeight() const
Definition: vpImage.h:150
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:92
virtual void displayLine(const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color, unsigned int thickness=1)=0
static void read(vpImage< unsigned char > &I, const char *filename)
Definition: vpImageIo.cpp:277
static const vpColor yellow
Definition: vpColor.h:175
static const vpColor blue
Definition: vpColor.h:173