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