ViSP
 All Classes Functions Variables Enumerations Enumerator Friends Groups Pages
displayGDI.cpp
1 /****************************************************************************
2  *
3  * $Id: displayGDI.cpp 4604 2014-01-21 14:15:23Z 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  * Windows' GDI Display Test
36  *
37  * Authors:
38  * Bruno Renier
39  *
40  *****************************************************************************/
50 #include <visp/vpDebug.h>
51 #include <visp/vpConfig.h>
52 
53 #if ( defined(_WIN32) && defined(VISP_HAVE_GDI) )
54 
55 #include <visp/vpDisplayGDI.h>
56 
57 #include <visp/vpImage.h>
58 #include <visp/vpImageIo.h>
59 #include <visp/vpParseArgv.h>
60 #include <visp/vpIoTools.h>
61 
71 // List of allowed command line options
72 #define GETOPTARGS "cdi:o:h"
73 
87 void usage(const char *name, const char *badparam, std::string ipath, std::string opath, std::string user)
88 {
89  fprintf(stdout, "\n\
90 Read an image on the disk, display it using GDI, 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 the task manager under \n\
122  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(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
130 
131 }
132 
148 bool getOptions(int argc, const char **argv,
149  std::string &ipath, std::string &opath, bool &click_allowed,
150  std::string user, bool &display)
151 {
152  const char *optarg;
153  int c;
154  while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg)) > 1) {
155 
156  switch (c) {
157  case 'c': click_allowed = false; break;
158  case 'd': display = false; break;
159  case 'i': ipath = optarg; break;
160  case 'o': opath = optarg; break;
161  case 'h': usage(argv[0], NULL, ipath, opath, user); return false; break;
162 
163  default:
164  usage(argv[0], optarg, ipath, opath, user); return false; break;
165  }
166  }
167 
168  if ((c == 1) || (c == -1)) {
169  // standalone param or error
170  usage(argv[0], NULL, ipath, opath, user);
171  std::cerr << "ERROR: " << std::endl;
172  std::cerr << " Bad argument " << optarg << std::endl << std::endl;
173  return false;
174  }
175 
176  return true;
177 }
178 
179 int
180 main(int argc, const char ** argv)
181 {
182  try {
183  std::string env_ipath;
184  std::string opt_ipath;
185  std::string opt_opath;
186  std::string ipath;
187  std::string opath;
188  std::string filename;
189  std::string username;
190  bool opt_click_allowed = true;
191  bool opt_display = true;
192 
193  // Get the VISP_IMAGE_PATH environment variable value
194  char *ptenv = getenv("VISP_INPUT_IMAGE_PATH");
195  if (ptenv != NULL)
196  env_ipath = ptenv;
197 
198  // Set the default input path
199  if (! env_ipath.empty())
200  ipath = env_ipath;
201 
202  // Set the default output path
203  opt_opath = "C:\\temp";
204 
205  // Get the user login name
206  vpIoTools::getUserName(username);
207 
208  // Read the command line options
209  if (getOptions(argc, argv, opt_ipath, opt_opath,
210  opt_click_allowed, username, opt_display) == false) {
211  exit (-1);
212  }
213 
214  // Get the option values
215  if (!opt_ipath.empty())
216  ipath = opt_ipath;
217  if (!opt_opath.empty())
218  opath = opt_opath;
219 
220  // Append to the output path string, the login name of the user
221  std::string odirname = opath + vpIoTools::path("/") + username;
222 
223  // Test if the output path exist. If no try to create it
224  if (vpIoTools::checkDirectory(odirname) == false) {
225  try {
226  // Create the dirname
227  vpIoTools::makeDirectory(odirname);
228  }
229  catch (...) {
230  usage(argv[0], NULL, ipath, opath, username);
231  std::cerr << std::endl
232  << "ERROR:" << std::endl;
233  std::cerr << " Cannot create " << odirname << std::endl;
234  std::cerr << " Check your -o " << opath << " option " << std::endl;
235  exit(-1);
236  }
237  }
238 
239  // Compare ipath and env_ipath. If they differ, we take into account
240  // the input path comming from the command line option
241  if (!opt_ipath.empty() && !env_ipath.empty()) {
242  if (ipath != env_ipath) {
243  std::cout << std::endl
244  << "WARNING: " << std::endl;
245  std::cout << " Since -i <visp image path=" << ipath << "> "
246  << " is different from VISP_IMAGE_PATH=" << env_ipath << std::endl
247  << " we skip the environment variable." << std::endl;
248  }
249  }
250 
251  // Test if an input path is set
252  if (opt_ipath.empty() && env_ipath.empty()){
253  usage(argv[0], NULL, ipath, opath, username);
254  std::cerr << std::endl
255  << "ERROR:" << std::endl;
256  std::cerr << " Use -i <visp image path> option or set VISP_INPUT_IMAGE_PATH "
257  << std::endl
258  << " environment variable to specify the location of the " << std::endl
259  << " image path where test images are located." << std::endl << std::endl;
260  exit(-1);
261  }
262 
263  // Create a grey level image
265  vpImagePoint ip, ip1, ip2;
266 
267  // Load a grey image from the disk
268  filename = ipath + vpIoTools::path("/ViSP-images/Klimt/Klimt.pgm");
269  vpImageIo::read(I, filename) ;
270 
271  // For this grey level image, open a GDI display at position 100,100
272  // in the screen, and with title "GDI display"
273  vpDisplayGDI display;
274 
275  if (opt_display) {
276  // We open a window using GDI.
277  // Its size is automatically defined by the image (I) size
278  display.init(I, 100, 100, "GDI display") ;
279 
280  // Display the image
281  vpDisplay::display(I) ;
282 
283  // Display in overlay a red cross at position 10,10 in the
284  // image. The lines are 10 pixels long
285  ip.set_i( 100 );
286  ip.set_j( 10 );
287 
289 
290  // Display in overlay horizontal red lines
291  for (unsigned i=0 ; i < I.getHeight() ; i+=20) {
292  ip1.set_i( i );
293  ip1.set_j( 0 );
294  ip2.set_i( i );
295  ip2.set_j( I.getWidth() );
296  vpDisplay::displayLine(I, ip1, ip2, vpColor::red) ;
297  }
298 
299  // Display a ligne in the diagonal
300  ip1.set_i( -10 );
301  ip1.set_j( -10 );
302  ip2.set_i( I.getHeight() + 10 );
303  ip2.set_j( I.getWidth() + 10 );
304 
305  vpDisplay::displayLine(I, ip1, ip2, vpColor::red) ;
306 
307  // Display in overlay vertical green dot lines
308  for (unsigned i=0 ; i < I.getWidth() ; i+=20) {
309  ip1.set_i( 0 );
310  ip1.set_j( i );
311  ip2.set_i( I.getWidth() );
312  ip2.set_j( i );
314  }
315 
316  // Display a rectangle
317  ip.set_i( I.getHeight() - 45 );
318  ip.set_j( -10 );
320 
321  // Display in overlay a blue arrow
322  ip1.set_i( 0 );
323  ip1.set_j( 0 );
324  ip2.set_i( 100 );
325  ip2.set_j( 100 );
326  vpDisplay::displayArrow(I, ip1, ip2, vpColor::blue) ;
327 
328  // Display in overlay some circles. The position of the center is 200, 200
329  // the radius is increased by 20 pixels for each circle
330 
331  for (unsigned int i=0 ; i < 100 ; i+=20) {
332  ip.set_i( 80 );
333  ip.set_j( 80 );
335  }
336 
337  ip.set_i( -10 );
338  ip.set_j( 300 );
340 
341  // Display in overlay a yellow string
342  ip.set_i( 85 );
343  ip.set_j( 100 );
345  "ViSP is a marvelous software",
346  vpColor::yellow) ;
347  //Flush the display
348  vpDisplay::flush(I);
349 
350  // Create a color image
351  vpImage<vpRGBa> Ioverlay ;
352  // Updates the color image with the original loaded image and the overlay
353  vpDisplay::getImage(I, Ioverlay) ;
354 
355  // Write the color image on the disk
356  filename = odirname + vpIoTools::path("/Klimt_grey.overlay.ppm");
357  vpImageIo::write(Ioverlay, filename) ;
358 
359  // If click is allowed, wait for a mouse click to close the display
360  if (opt_click_allowed) {
361  std::cout << "\nA click to close the windows..." << std::endl;
362  // Wait for a blocking mouse click
364  }
365 
366  // Close the display
367  vpDisplay::close(I);
368  }
369 
370  // Create a color image
371  vpImage<vpRGBa> Irgba ;
372 
373  // Load a grey image from the disk and convert it to a color image
374  filename = ipath + vpIoTools::path("/ViSP-images/Klimt/Klimt.pgm");
375  vpImageIo::read(Irgba, filename) ;
376 
377  // For this color image, open a GDI display at position 100,100
378  // in the screen, and with title "GDI color display"
379  vpDisplayGDI displayRGBa;
380 
381  if (opt_display) {
382  // We open a window using GDI.
383  // Its size is automatically defined by the image (Irgba) size
384  displayRGBa.init(Irgba, 100, 100, "GDI color display");
385 
386  // Display the color image
387  vpDisplay::display(Irgba) ;
388  vpDisplay::flush(Irgba) ;
389 
390  // If click is allowed, wait for a blocking mouse click to display a cross
391  // at the clicked pixel position
392  if (opt_click_allowed) {
393  std::cout << "\nA click to display a cross..." << std::endl;
394  // Blocking wait for a click. Get the position of the selected pixel
395  // (i correspond to the row and j to the column coordinates in the image)
396  vpDisplay::getClick(Irgba, ip);
397  // Display a red cross on the click pixel position
398  std::cout << "Cross position: " << ip << std::endl;
399  vpDisplay::displayCross(Irgba, ip, 15, vpColor::red);
400  }
401  else {
402  ip.set_i( 10 );
403  ip.set_j( 20 );
404  // Display a red cross at position i, j (i correspond to the row
405  // and j to the column coordinates in the image)
406  std::cout << "Cross position: " << ip << std::endl;
407  vpDisplay::displayCross(Irgba, ip, 15, vpColor::red);
408 
409  }
410  // Flush the display. Sometimes the display content is
411  // bufferized. Force to display the content that has been bufferized.
412  vpDisplay::flush(Irgba);
413 
414  // If click is allowed, wait for a blocking mouse click to exit.
415  if (opt_click_allowed) {
416  std::cout << "\nA click to exit the program..." << std::endl;
417  vpDisplay::getClick(Irgba) ;
418  std::cout << "Bye" << std::endl;
419  }
420  }
421  }
422  catch(vpException e) {
423  std::cout << "Catch an exception: " << e << std::endl;
424  return 1;
425  }
426 }
427 #else
428 int
429 main()
430 {
431  vpERROR_TRACE("GDI display only works under windows...");
432 }
433 #endif
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:452
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:2031
unsigned int getWidth() const
Definition: vpImage.h:159
#define vpERROR_TRACE
Definition: vpDebug.h:395
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:132
error that can be emited by ViSP classes.
Definition: vpException.h:76
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:1994
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
void set_i(const double ii)
Definition: vpImagePoint.h:158
static void display(const vpImage< unsigned char > &I)
Definition: vpDisplay.cpp:206
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
void init(vpImage< unsigned char > &I, int winx=-1, int winy=-1, const char *title=NULL)
static void getImage(const vpImage< unsigned char > &Is, vpImage< vpRGBa > &Id)
Definition: vpDisplay.cpp:324
virtual void displayDotLine(const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color, unsigned int thickness=1)=0
void set_j(const double jj)
Definition: vpImagePoint.h:169
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:278
static const vpColor yellow
Definition: vpColor.h:175
static const vpColor blue
Definition: vpColor.h:173