ViSP
 All Classes Functions Variables Enumerations Enumerator Friends Groups Pages
displayGDI.cpp
1 /****************************************************************************
2  *
3  * $Id: displayGDI.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  * 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  std::string env_ipath;
183  std::string opt_ipath;
184  std::string opt_opath;
185  std::string ipath;
186  std::string opath;
187  std::string filename;
188  std::string username;
189  bool opt_click_allowed = true;
190  bool opt_display = true;
191 
192  // Get the VISP_IMAGE_PATH environment variable value
193  char *ptenv = getenv("VISP_INPUT_IMAGE_PATH");
194  if (ptenv != NULL)
195  env_ipath = ptenv;
196 
197  // Set the default input path
198  if (! env_ipath.empty())
199  ipath = env_ipath;
200 
201  // Set the default output path
202  opt_opath = "C:\\temp";
203 
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  try {
270  vpImageIo::read(I, filename) ;
271  }
272  catch (...) {
273  return -1;
274  }
275 
276  // For this grey level image, open a GDI display at position 100,100
277  // in the screen, and with title "GDI display"
278  vpDisplayGDI display;
279 
280  if (opt_display) {
281  // We open a window using GDI.
282  // Its size is automatically defined by the image (I) size
283  display.init(I, 100, 100, "GDI display") ;
284 
285  // Display the image
286  vpDisplay::display(I) ;
287 
288  // Display in overlay a red cross at position 10,10 in the
289  // image. The lines are 10 pixels long
290  ip.set_i( 100 );
291  ip.set_j( 10 );
292 
294 
295  // Display in overlay horizontal red lines
296  for (unsigned i=0 ; i < I.getHeight() ; i+=20) {
297  ip1.set_i( i );
298  ip1.set_j( 0 );
299  ip2.set_i( i );
300  ip2.set_j( I.getWidth() );
301  vpDisplay::displayLine(I, ip1, ip2, vpColor::red) ;
302  }
303 
304  // Display a ligne in the diagonal
305  ip1.set_i( -10 );
306  ip1.set_j( -10 );
307  ip2.set_i( I.getHeight() + 10 );
308  ip2.set_j( I.getWidth() + 10 );
309 
310  vpDisplay::displayLine(I, ip1, ip2, vpColor::red) ;
311 
312  // Display in overlay vertical green dot lines
313  for (unsigned i=0 ; i < I.getWidth() ; i+=20) {
314  ip1.set_i( 0 );
315  ip1.set_j( i );
316  ip2.set_i( I.getWidth() );
317  ip2.set_j( i );
319  }
320 
321  // Display a rectangle
322  ip.set_i( I.getHeight() - 45 );
323  ip.set_j( -10 );
325 
326  // Display in overlay a blue arrow
327  ip1.set_i( 0 );
328  ip1.set_j( 0 );
329  ip2.set_i( 100 );
330  ip2.set_j( 100 );
331  vpDisplay::displayArrow(I, ip1, ip2, vpColor::blue) ;
332 
333  // Display in overlay some circles. The position of the center is 200, 200
334  // the radius is increased by 20 pixels for each circle
335 
336  for (unsigned int i=0 ; i < 100 ; i+=20) {
337  ip.set_i( 80 );
338  ip.set_j( 80 );
340  }
341 
342  ip.set_i( -10 );
343  ip.set_j( 300 );
345 
346  // Display in overlay a yellow string
347  ip.set_i( 85 );
348  ip.set_j( 100 );
350  "ViSP is a marvelous software",
351  vpColor::yellow) ;
352  //Flush the display
353  vpDisplay::flush(I);
354 
355  // Create a color image
356  vpImage<vpRGBa> Ioverlay ;
357  // Updates the color image with the original loaded image and the overlay
358  vpDisplay::getImage(I, Ioverlay) ;
359 
360  // Write the color image on the disk
361  filename = odirname + vpIoTools::path("/Klimt_grey.overlay.ppm");
362  vpImageIo::write(Ioverlay, filename) ;
363 
364  // If click is allowed, wait for a mouse click to close the display
365  if (opt_click_allowed) {
366  std::cout << "\nA click to close the windows..." << std::endl;
367  // Wait for a blocking mouse click
369  }
370 
371  // Close the display
372  vpDisplay::close(I);
373  }
374 
375  // Create a color image
376  vpImage<vpRGBa> Irgba ;
377 
378  // Load a grey image from the disk and convert it to a color image
379  filename = ipath + vpIoTools::path("/ViSP-images/Klimt/Klimt.pgm");
380  try {
381  vpImageIo::read(Irgba, filename) ;
382  }
383  catch (...) {
384  return -1;
385  }
386 
387  // For this color image, open a GDI display at position 100,100
388  // in the screen, and with title "GDI color display"
389  vpDisplayGDI displayRGBa;
390 
391  if (opt_display) {
392  // We open a window using GDI.
393  // Its size is automatically defined by the image (Irgba) size
394  displayRGBa.init(Irgba, 100, 100, "GDI color display");
395 
396  // Display the color image
397  vpDisplay::display(Irgba) ;
398  vpDisplay::flush(Irgba) ;
399 
400  // If click is allowed, wait for a blocking mouse click to display a cross
401  // at the clicked pixel position
402  if (opt_click_allowed) {
403  std::cout << "\nA click to display a cross..." << std::endl;
404  // Blocking wait for a click. Get the position of the selected pixel
405  // (i correspond to the row and j to the column coordinates in the image)
406  vpDisplay::getClick(Irgba, ip);
407  // Display a red cross on the click pixel position
408  std::cout << "Cross position: " << ip << std::endl;
409  vpDisplay::displayCross(Irgba, ip, 15, vpColor::red);
410  }
411  else {
412  ip.set_i( 10 );
413  ip.set_j( 20 );
414  // Display a red cross at position i, j (i correspond to the row
415  // and j to the column coordinates in the image)
416  std::cout << "Cross position: " << ip << std::endl;
417  vpDisplay::displayCross(Irgba, ip, 15, vpColor::red);
418 
419  }
420  // Flush the display. Sometimes the display content is
421  // bufferized. Force to display the content that has been bufferized.
422  vpDisplay::flush(Irgba);
423 
424  // If click is allowed, wait for a blocking mouse click to exit.
425  if (opt_click_allowed) {
426  std::cout << "\nA click to exit the program..." << std::endl;
427  vpDisplay::getClick(Irgba) ;
428  std::cout << "Bye" << std::endl;
429  }
430  }
431 }
432 #else
433 int
434 main()
435 {
436  vpERROR_TRACE("GDI display only works under windows...");
437 }
438 #endif
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
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
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:133
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
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: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