Visual Servoing Platform  version 3.0.1
mbtKltTracking.cpp
1 /****************************************************************************
2  *
3  * This file is part of the ViSP software.
4  * Copyright (C) 2005 - 2017 by Inria. All rights reserved.
5  *
6  * This software is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * ("GPL") version 2 as published by the Free Software Foundation.
9  * See the file LICENSE.txt at the root directory of this source
10  * distribution for additional information about the GNU GPL.
11  *
12  * For using ViSP with software that can not be combined with the GNU
13  * GPL, please contact Inria about acquiring a ViSP Professional
14  * Edition License.
15  *
16  * See http://visp.inria.fr for more information.
17  *
18  * This software was developed at:
19  * Inria Rennes - Bretagne Atlantique
20  * Campus Universitaire de Beaulieu
21  * 35042 Rennes Cedex
22  * France
23  *
24  * If you have questions regarding the use of this file, please contact
25  * Inria at visp@inria.fr
26  *
27  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
28  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
29  *
30  * Description:
31  * Example of MBT KLT Tracking.
32  *
33  * Authors:
34  * Aurelien Yol
35  *
36  *****************************************************************************/
37 
44 #include <iostream>
45 #include <visp3/core/vpConfig.h>
46 
47 #if defined(VISP_HAVE_MODULE_MBT) && defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(VISP_HAVE_DISPLAY) && (VISP_HAVE_OPENCV_VERSION >= 0x020100)
48 
49 #include <visp3/core/vpDebug.h>
50 #include <visp3/gui/vpDisplayD3D.h>
51 #include <visp3/gui/vpDisplayGTK.h>
52 #include <visp3/gui/vpDisplayGDI.h>
53 #include <visp3/gui/vpDisplayOpenCV.h>
54 #include <visp3/gui/vpDisplayX.h>
55 #include <visp3/core/vpHomogeneousMatrix.h>
56 #include <visp3/io/vpImageIo.h>
57 #include <visp3/core/vpIoTools.h>
58 #include <visp3/core/vpMath.h>
59 #include <visp3/io/vpVideoReader.h>
60 #include <visp3/io/vpParseArgv.h>
61 #include <visp3/mbt/vpMbKltTracker.h>
62 
63 #define GETOPTARGS "x:m:i:n:dchtfolwv"
64 
65 void usage(const char *name, const char *badparam);
66 bool getOptions(int argc, const char **argv, std::string &ipath, std::string &configFile, std::string &modelFile,
67  std::string &initFile, bool &displayKltPoints, bool &click_allowed, bool &display,
68  bool& cao3DModel, bool &useOgre, bool &showOgreConfigDialog, bool &useScanline, bool &computeCovariance);
69 
70 void usage(const char *name, const char *badparam)
71 {
72  fprintf(stdout, "\n\
73 Example of tracking based on the 3D model.\n\
74 \n\
75 SYNOPSIS\n\
76  %s [-i <test image path>] [-x <config file>]\n\
77  [-m <model name>] [-n <initialisation file base name>]\n\
78  [-t] [-c] [-d] [-h] [-f] [-o] [-w] [-l] [-v]",
79  name );
80 
81  fprintf(stdout, "\n\
82 OPTIONS: \n\
83  -i <input image path> \n\
84  Set image input path.\n\
85  From this path read images \n\
86  \"ViSP-images/mbt/cube/image%%04d.ppm\". These \n\
87  images come from ViSP-images-x.y.z.tar.gz available \n\
88  on the ViSP website.\n\
89  Setting the VISP_INPUT_IMAGE_PATH environment\n\
90  variable produces the same behaviour than using\n\
91  this option.\n\
92 \n\
93  -x <config file> \n\
94  Set the config file (the xml file) to use.\n\
95  The config file is used to specify the parameters of the tracker.\n\
96 \n\
97  -m <model name> \n\
98  Specify the name of the file of the model\n\
99  The model can either be a vrml model (.wrl) or a .cao file.\n\
100 \n\
101  -f \n\
102  Do not use the vrml model, use the .cao one. These two models are \n\
103  equivalent and comes from ViSP-images-x.y.z.tar.gz available on the ViSP\n\
104  website. However, the .cao model allows to use the 3d model based tracker \n\
105  without Coin.\n\
106 \n\
107  -n <initialisation file base name> \n\
108  Base name of the initialisation file. The file will be 'base_name'.init .\n\
109  This base name is also used for the optionnal picture specifying where to \n\
110  click (a .ppm picture).\
111 \n\
112  -t \n\
113  Turn off the display of the the klt points. \n\
114 \n\
115  -d \n\
116  Turn off the display.\n\
117 \n\
118  -c\n\
119  Disable the mouse click. Useful to automaze the \n\
120  execution of this program without humain intervention.\n\
121 \n\
122  -o\n\
123  Use Ogre3D for visibility tests\n\
124 \n\
125  -w\n\
126  When Ogre3D is enable [-o] show Ogre3D configuration dialog thatallows to set the renderer.\n\
127 \n\
128  -l\n\
129  Use the scanline for visibility tests.\n\
130 \n\
131  -v\n\
132  Compute covariance matrix.\n\
133 \n\
134  -h \n\
135  Print the help.\n\n");
136 
137  if (badparam)
138  fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
139 }
140 
141 
142 bool getOptions(int argc, const char **argv, std::string &ipath, std::string &configFile, std::string &modelFile,
143  std::string &initFile, bool &displayKltPoints, bool &click_allowed, bool &display,
144  bool& cao3DModel, bool &useOgre, bool &showOgreConfigDialog, bool &useScanline, bool &computeCovariance)
145 {
146  const char *optarg_;
147  int c;
148  while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) {
149 
150  switch (c) {
151  case 'i': ipath = optarg_; break;
152  case 'x': configFile = optarg_; break;
153  case 'm': modelFile = optarg_; break;
154  case 'n': initFile = optarg_; break;
155  case 't': displayKltPoints = false; break;
156  case 'f': cao3DModel = true; break;
157  case 'c': click_allowed = false; break;
158  case 'd': display = false; break;
159  case 'o': useOgre = true; break;
160  case 'l': useScanline = true; break;
161  case 'w': showOgreConfigDialog = true; break;
162  case 'v': computeCovariance = true; break;
163  case 'h': usage(argv[0], NULL); return false; break;
164 
165  default:
166  usage(argv[0], optarg_);
167  return false; break;
168  }
169  }
170 
171  if ((c == 1) || (c == -1)) {
172  // standalone param or error
173  usage(argv[0], NULL);
174  std::cerr << "ERROR: " << std::endl;
175  std::cerr << " Bad argument " << optarg_ << std::endl << std::endl;
176  return false;
177  }
178 
179  return true;
180 }
181 
182 int
183 main(int argc, const char ** argv)
184 {
185  try {
186  std::string env_ipath;
187  std::string opt_ipath;
188  std::string ipath;
189  std::string opt_configFile;
190  std::string configFile;
191  std::string opt_modelFile;
192  std::string modelFile;
193  std::string opt_initFile;
194  std::string initFile;
195  bool displayKltPoints = true;
196  bool opt_click_allowed = true;
197  bool opt_display = true;
198  bool cao3DModel = false;
199  bool useOgre = false;
200  bool showOgreConfigDialog = false;
201  bool useScanline = false;
202  bool computeCovariance = false;
203  bool quit = false;
204 
205  // Get the visp-images-data package path or VISP_INPUT_IMAGE_PATH environment variable value
206  env_ipath = vpIoTools::getViSPImagesDataPath();
207 
208  // Set the default input path
209  if (! env_ipath.empty())
210  ipath = env_ipath;
211 
212  // Read the command line options
213  if (!getOptions(argc, argv, opt_ipath, opt_configFile, opt_modelFile, opt_initFile, displayKltPoints,
214  opt_click_allowed, opt_display, cao3DModel, useOgre, showOgreConfigDialog, useScanline,
215  computeCovariance)) {
216  return (-1);
217  }
218 
219  // Test if an input path is set
220  if (opt_ipath.empty() && env_ipath.empty() ){
221  usage(argv[0], NULL);
222  std::cerr << std::endl
223  << "ERROR:" << std::endl;
224  std::cerr << " Use -i <visp image path> option or set VISP_INPUT_IMAGE_PATH "
225  << std::endl
226  << " environment variable to specify the location of the " << std::endl
227  << " image path where test images are located." << std::endl
228  << std::endl;
229 
230  return (-1);
231  }
232 
233  // Get the option values
234  if (!opt_ipath.empty())
235  ipath = vpIoTools::createFilePath(opt_ipath, "ViSP-images/mbt/cube/image%04d.pgm");
236  else
237  ipath = vpIoTools::createFilePath(env_ipath, "ViSP-images/mbt/cube/image%04d.pgm");
238 
239  if (!opt_configFile.empty())
240  configFile = opt_configFile;
241  else if (!opt_ipath.empty())
242  configFile = vpIoTools::createFilePath(opt_ipath, "ViSP-images/mbt/cube.xml");
243  else
244  configFile = vpIoTools::createFilePath(env_ipath, "ViSP-images/mbt/cube.xml");
245 
246  if (!opt_modelFile.empty()){
247  modelFile = opt_modelFile;
248  }else{
249  std::string modelFileCao = "ViSP-images/mbt/cube.cao";
250  std::string modelFileWrl = "ViSP-images/mbt/cube.wrl";
251 
252  if(!opt_ipath.empty()){
253  if(cao3DModel){
254  modelFile = vpIoTools::createFilePath(opt_ipath, modelFileCao);
255  }
256  else{
257 #ifdef VISP_HAVE_COIN3D
258  modelFile = vpIoTools::createFilePath(opt_ipath, modelFileWrl);
259 #else
260  std::cerr << "Coin is not detected in ViSP. Use the .cao model instead." << std::endl;
261  modelFile = vpIoTools::createFilePath(opt_ipath, modelFileCao);
262 #endif
263  }
264  }
265  else{
266  if(cao3DModel){
267  modelFile = vpIoTools::createFilePath(env_ipath, modelFileCao);
268  }
269  else{
270 #ifdef VISP_HAVE_COIN3D
271  modelFile = vpIoTools::createFilePath(env_ipath, modelFileWrl);
272 #else
273  std::cerr << "Coin is not detected in ViSP. Use the .cao model instead." << std::endl;
274  modelFile = vpIoTools::createFilePath(env_ipath, modelFileCao);
275 #endif
276  }
277  }
278  }
279 
280  if (!opt_initFile.empty())
281  initFile = opt_initFile;
282  else if (!opt_ipath.empty())
283  initFile = vpIoTools::createFilePath(opt_ipath, "ViSP-images/mbt/cube");
284  else
285  initFile = vpIoTools::createFilePath(env_ipath, "ViSP-images/mbt/cube");
286 
288  vpVideoReader reader;
289 
290  reader.setFileName(ipath);
291  try{
292  reader.open(I);
293  }catch(...){
294  std::cout << "Cannot open sequence: " << ipath << std::endl;
295  return -1;
296  }
297 
298  reader.acquire(I);
299 
300  // initialise a display
301 #if defined VISP_HAVE_X11
302  vpDisplayX display;
303 #elif defined VISP_HAVE_GDI
304  vpDisplayGDI display;
305 #elif defined VISP_HAVE_OPENCV
306  vpDisplayOpenCV display;
307 #elif defined VISP_HAVE_D3D9
308  vpDisplayD3D display;
309 #elif defined VISP_HAVE_GTK
310  vpDisplayGTK display;
311 #else
312  opt_display = false;
313 #endif
314  if (opt_display)
315  {
316 #if (defined VISP_HAVE_DISPLAY)
317  display.init(I, 100, 100, "Test tracking") ;
318 #endif
319  vpDisplay::display(I) ;
320  vpDisplay::flush(I);
321  }
322 
323  vpMbKltTracker tracker;
325 
326  // Load tracker config file (camera parameters and moving edge settings)
327  vpCameraParameters cam;
328 #if defined (VISP_HAVE_XML2)
329  // From the xml file
330  tracker.loadConfigFile(configFile);
331 #else
332  // By setting the parameters:
333  cam.initPersProjWithoutDistortion(547, 542, 338, 234);
334 
335  vpKltOpencv klt;
336  klt.setMaxFeatures(10000);
337  klt.setWindowSize(5);
338  klt.setQuality(0.01);
339  klt.setMinDistance(5);
340  klt.setHarrisFreeParameter(0.01);
341  klt.setBlockSize(3);
342  klt.setPyramidLevels(3);
343 
344  tracker.setCameraParameters(cam);
345  tracker.setKltOpencv(klt);
346  tracker.setAngleAppear( vpMath::rad(65) );
347  tracker.setAngleDisappear( vpMath::rad(75) );
348  tracker.setMaskBorder(5);
349 
350  // Specify the clipping to use
351  tracker.setNearClippingDistance(0.01);
352  tracker.setFarClippingDistance(0.90);
354  // tracker.setClipping(tracker.getClipping() | vpMbtPolygon::LEFT_CLIPPING | vpMbtPolygon::RIGHT_CLIPPING | vpMbtPolygon::UP_CLIPPING | vpMbtPolygon::DOWN_CLIPPING); // Equivalent to FOV_CLIPPING
355 #endif
356 
357  // Display the klt points
358  tracker.setDisplayFeatures(displayKltPoints);
359 
360  // Tells if the tracker has to use Ogre3D for visibility tests
361  tracker.setOgreVisibilityTest(useOgre);
362  if (useOgre)
363  tracker.setOgreShowConfigDialog(showOgreConfigDialog);
364 
365  // Tells if the tracker has to use the scanline visibility tests
366  tracker.setScanLineVisibilityTest(useScanline);
367 
368  // Tells if the tracker has to compute the covariance matrix
369  tracker.setCovarianceComputation(computeCovariance);
370 
371  // Retrieve the camera parameters from the tracker
372  tracker.getCameraParameters(cam);
373 
374  // Loop to position the cube
375  if (opt_display && opt_click_allowed)
376  {
377  while(!vpDisplay::getClick(I,false)){
379  vpDisplay::displayText(I, 15, 10, "click after positioning the object", vpColor::red);
380  vpDisplay::flush(I) ;
381  }
382  }
383 
384  // Load the 3D model (either a vrml file or a .cao file)
385  tracker.loadModel(modelFile);
386 
387  // Initialise the tracker by clicking on the image
388  // This function looks for
389  // - a ./cube/cube.init file that defines the 3d coordinates (in meter, in the object basis) of the points used for the initialisation
390  // - a ./cube/cube.ppm file to display where the user have to click (optionnal, set by the third parameter)
391  if (opt_display && opt_click_allowed)
392  {
393  tracker.initClick(I, initFile, true);
394  tracker.getPose(cMo);
395  // display the 3D model at the given pose
396  tracker.display(I,cMo, cam, vpColor::red);
397  }
398  else
399  {
400  vpHomogeneousMatrix cMoi(0.02044769891, 0.1101505452, 0.5078963719, 2.063603907, 1.110231561, -0.4392789872);
401  tracker.initFromPose(I, cMoi);
402  }
403 
404  //track the model
405  tracker.track(I);
406  tracker.getPose(cMo);
407 
408  if (opt_display)
409  vpDisplay::flush(I);
410 
411  while (!reader.end())
412  {
413  // acquire a new image
414  reader.acquire(I);
415  // display the image
416  if (opt_display)
418 
419  // Test to reset the tracker
420  if (reader.getFrameIndex() == reader.getFirstFrameIndex() + 10) {
421  vpTRACE("Test reset tracker");
422  if (opt_display)
424  tracker.resetTracker();
425 #if defined (VISP_HAVE_XML2)
426  tracker.loadConfigFile(configFile);
427 #else
428  // By setting the parameters:
429  cam.initPersProjWithoutDistortion(547, 542, 338, 234);
430 
431  vpKltOpencv klt;
432  klt.setMaxFeatures(10000);
433  klt.setWindowSize(5);
434  klt.setQuality(0.01);
435  klt.setMinDistance(5);
436  klt.setHarrisFreeParameter(0.01);
437  klt.setBlockSize(3);
438  klt.setPyramidLevels(3);
439 
440  tracker.setCameraParameters(cam);
441  tracker.setKltOpencv(klt);
442  tracker.setAngleAppear( vpMath::rad(65) );
443  tracker.setAngleDisappear( vpMath::rad(75) );
444  tracker.setMaskBorder(5);
445 
446  // Specify the clipping to use
447  tracker.setNearClippingDistance(0.01);
448  tracker.setFarClippingDistance(0.90);
450  // tracker.setClipping(tracker.getClipping() | vpMbtPolygon::LEFT_CLIPPING | vpMbtPolygon::RIGHT_CLIPPING | vpMbtPolygon::UP_CLIPPING | vpMbtPolygon::DOWN_CLIPPING); // Equivalent to FOV_CLIPPING
451 #endif
452  tracker.loadModel(modelFile);
453  tracker.setCameraParameters(cam);
454  tracker.setOgreVisibilityTest(useOgre);
455  tracker.setScanLineVisibilityTest(useScanline);
456  tracker.setCovarianceComputation(computeCovariance);
457  tracker.initFromPose(I, cMo);
458  }
459 
460  // Test to set an initial pose
461  if (reader.getFrameIndex() == reader.getFirstFrameIndex() + 50) {
462  cMo.buildFrom(0.0439540832, 0.0845870108, 0.5477322481, 2.179498458, 0.8611798108, -0.3491961946);
463  vpTRACE("Test set pose");
464  tracker.setPose(I, cMo);
465 // if (opt_display) {
466 // // display the 3D model
467 // tracker.display(I, cMo, cam, vpColor::darkRed);
468 // // display the frame
469 // vpDisplay::displayFrame (I, cMo, cam, 0.05);
474 // }
475  }
476 
477  // track the object: stop tracking from frame 40 to 50
478  if (reader.getFrameIndex() - reader.getFirstFrameIndex() < 40 || reader.getFrameIndex() - reader.getFirstFrameIndex() >= 50) {
479  tracker.track(I);
480  tracker.getPose(cMo);
481  if (opt_display) {
482  // display the 3D model
483  tracker.display(I, cMo, cam, vpColor::darkRed);
484  // display the frame
485  vpDisplay::displayFrame (I, cMo, cam, 0.05);
486  }
487  }
488 
489  if (opt_click_allowed) {
490  vpDisplay::displayText(I, 10, 10, "Click to quit", vpColor::red);
491  if (vpDisplay::getClick(I, false)) {
492  quit = true;
493  break;
494  }
495  }
496 
497  if(computeCovariance) {
498  std::cout << "Covariance matrix: \n" << tracker.getCovarianceMatrix() << std::endl << std::endl;
499  }
500 
501  vpDisplay::flush(I) ;
502  }
503  if (opt_click_allowed && !quit) {
505  }
506 
507  reader.close();
508 
509 #if defined (VISP_HAVE_XML2)
510  // Cleanup memory allocated by xml library used to parse the xml config file in vpMbKltTracker::loadConfigFile()
512 #endif
513 
514 #if defined(VISP_HAVE_COIN3D) && (COIN_MAJOR_VERSION == 3)
515  // Cleanup memory allocated by Coin library used to load a vrml model in vpMbKltTracker::loadModel()
516  // We clean only if Coin was used.
517  if(! cao3DModel)
518  SoDB::finish();
519 #endif
520 
521  return 0;
522  }
523  catch(vpException &e) {
524  std::cout << "Catch an exception: " << e << std::endl;
525  return 1;
526  }
527 }
528 
529 #else
530 
531 int main()
532 {
533  std::cout << "visp_mbt, visp_gui modules and OpenCV are required to run this example." << std::endl;
534  return 0;
535 
536 }
537 
538 #endif
virtual void setKltOpencv(const vpKltOpencv &t)
virtual unsigned int getClipping() const
Definition: vpMbTracker.h:208
virtual void track(const vpImage< unsigned char > &I)
virtual void setDisplayFeatures(const bool displayF)
Definition: vpMbTracker.h:411
virtual void setCovarianceComputation(const bool &flag)
Definition: vpMbTracker.h:398
virtual void getPose(vpHomogeneousMatrix &cMo_) const
Definition: vpMbTracker.h:333
virtual void setScanLineVisibilityTest(const bool &v)
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
static std::string getViSPImagesDataPath()
Definition: vpIoTools.cpp:1157
void setHarrisFreeParameter(double harris_k)
virtual void setAngleDisappear(const double &a)
Definition: vpMbTracker.h:382
Implementation of an homogeneous matrix and operations on such kind of matrices.
static const vpColor darkRed
Definition: vpColor.h:164
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:128
void setMaxFeatures(const int maxCount)
static void displayText(const vpImage< unsigned char > &I, const vpImagePoint &ip, const std::string &s, const vpColor &color)
Use the X11 console to display images on unix-like OS. Thus to enable this class X11 should be instal...
Definition: vpDisplayX.h:153
Class that enables to manipulate easily a video file or a sequence of images. As it inherits from the...
void setMinDistance(double minDistance)
error that can be emited by ViSP classes.
Definition: vpException.h:73
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
static void flush(const vpImage< unsigned char > &I)
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
Definition: vpParseArgv.cpp:76
static const vpColor red
Definition: vpColor.h:163
virtual void loadConfigFile(const std::string &configFile)
void setQuality(double qualityLevel)
void initPersProjWithoutDistortion(const double px, const double py, const double u0, const double v0)
void setOgreShowConfigDialog(const bool showConfigDialog)
Definition: vpMbTracker.h:479
void open(vpImage< vpRGBa > &I)
Display for windows using Direct3D 3rd party. Thus to enable this class Direct3D should be installed...
Definition: vpDisplayD3D.h:107
#define vpTRACE
Definition: vpDebug.h:414
static std::string createFilePath(const std::string &parent, const std::string child)
Definition: vpIoTools.cpp:1366
static void display(const vpImage< unsigned char > &I)
The vpDisplayOpenCV allows to display image using the OpenCV library. Thus to enable this class OpenC...
Generic class defining intrinsic camera parameters.
The vpDisplayGTK allows to display image using the GTK 3rd party library. Thus to enable this class G...
Definition: vpDisplayGTK.h:138
void acquire(vpImage< vpRGBa > &I)
long getFirstFrameIndex() const
void setFileName(const char *filename)
virtual void setAngleAppear(const double &a)
Definition: vpMbTracker.h:371
Model based tracker using only KLT.
virtual void initClick(const vpImage< unsigned char > &I, const std::string &initFile, const bool displayHelp=false)
void setPyramidLevels(const int pyrMaxLevel)
void buildFrom(const vpTranslationVector &t, const vpRotationMatrix &R)
static double rad(double deg)
Definition: vpMath.h:104
void init(vpImage< unsigned char > &I, int winx=-1, int winy=-1, const std::string &title="")
static void displayFrame(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, double size, const vpColor &color=vpColor::none, unsigned int thickness=1, vpImagePoint offset=vpImagePoint(0, 0))
static void cleanup()
Definition: vpXmlParser.h:308
void setWindowSize(const int winSize)
long getFrameIndex() const
void setMaskBorder(const unsigned int &e)
virtual void loadModel(const char *modelFile, const bool verbose=false)
void setCameraParameters(const vpCameraParameters &cam)
virtual void getCameraParameters(vpCameraParameters &camera) const
Definition: vpMbTracker.h:201
virtual vpMatrix getCovarianceMatrix() const
Definition: vpMbTracker.h:213
virtual void setOgreVisibilityTest(const bool &v)
Wrapper for the KLT (Kanade-Lucas-Tomasi) feature tracker implemented in OpenCV. Thus to enable this ...
Definition: vpKltOpencv.h:76
void setBlockSize(const int blockSize)
virtual void setClipping(const unsigned int &flags)
virtual void setFarClippingDistance(const double &dist)
virtual void display(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const vpColor &col, const unsigned int thickness=1, const bool displayFullModel=false)
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
virtual void setNearClippingDistance(const double &dist)