Visual Servoing Platform  version 3.0.1
mbtEdgeTracking.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 model based tracking.
32  *
33  * Authors:
34  * Nicolas Melchior
35  * Romain Tallonneau
36  * Aurelien Yol
37  *
38  *****************************************************************************/
39 
46 #include <iostream>
47 #include <visp3/core/vpConfig.h>
48 
49 #if defined(VISP_HAVE_MODULE_MBT) && defined(VISP_HAVE_DISPLAY)
50 
51 #include <visp3/core/vpDebug.h>
52 #include <visp3/gui/vpDisplayD3D.h>
53 #include <visp3/gui/vpDisplayGTK.h>
54 #include <visp3/gui/vpDisplayGDI.h>
55 #include <visp3/gui/vpDisplayOpenCV.h>
56 #include <visp3/gui/vpDisplayX.h>
57 #include <visp3/core/vpHomogeneousMatrix.h>
58 #include <visp3/io/vpImageIo.h>
59 #include <visp3/core/vpIoTools.h>
60 #include <visp3/core/vpMath.h>
61 #include <visp3/io/vpVideoReader.h>
62 #include <visp3/io/vpParseArgv.h>
63 #include <visp3/mbt/vpMbEdgeTracker.h>
64 
65 #define GETOPTARGS "x:m:i:n:dchtfColwvp"
66 
67 void usage(const char *name, const char *badparam);
68 bool getOptions(int argc, const char **argv, std::string &ipath, std::string &configFile, std::string &modelFile,
69  std::string &initFile, bool &displayFeatures, bool &click_allowed, bool &display,
70  bool& cao3DModel, bool& trackCylinder, bool &useOgre, bool &showOgreConfigDialog,
71  bool &useScanline, bool &computeCovariance, bool &projectionError);
72 
73 void usage(const char *name, const char *badparam)
74 {
75  fprintf(stdout, "\n\
76 Example of tracking based on the 3D model.\n\
77 \n\
78 SYNOPSIS\n\
79  %s [-i <test image path>] [-x <config file>]\n\
80  [-m <model name>] [-n <initialisation file base name>]\n\
81  [-t] [-c] [-d] [-h] [-f] [-C] [-o] [-w] [-l] [-v] [-p]",
82  name );
83 
84  fprintf(stdout, "\n\
85 OPTIONS: \n\
86  -i <input image path> \n\
87  Set image input path.\n\
88  From this path read images \n\
89  \"ViSP-images/mbt/cube/image%%04d.ppm\". These \n\
90  images come from ViSP-images-x.y.z.tar.gz available \n\
91  on the ViSP website.\n\
92  Setting the VISP_INPUT_IMAGE_PATH environment\n\
93  variable produces the same behaviour than using\n\
94  this option.\n\
95 \n\
96  -x <config file> \n\
97  Set the config file (the xml file) to use.\n\
98  The config file is used to specify the parameters of the tracker.\n\
99 \n\
100  -m <model name> \n\
101  Specify the name of the file of the model\n\
102  The model can either be a vrml model (.wrl) or a .cao file.\n\
103 \n\
104  -f \n\
105  Do not use the vrml model, use the .cao one. These two models are \n\
106  equivalent and comes from ViSP-images-x.y.z.tar.gz available on the ViSP\n\
107  website. However, the .cao model allows to use the 3d model based tracker \n\
108  without Coin.\n\
109 \n\
110  -C \n\
111  Track only the cube (not the cylinder). In this case the models files are\n\
112  cube.cao or cube.wrl instead of cube_and_cylinder.cao and \n\
113  cube_and_cylinder.wrl.\n\
114 \n\
115  -n <initialisation file base name> \n\
116  Base name of the initialisation file. The file will be 'base_name'.init .\n\
117  This base name is also used for the optionnal picture specifying where to \n\
118  click (a .ppm picture).\
119 \n\
120  -t \n\
121  Turn off the display of the the moving edges. \n\
122 \n\
123  -d \n\
124  Turn off the display.\n\
125 \n\
126  -c\n\
127  Disable the mouse click. Useful to automaze the \n\
128  execution of this program without humain intervention.\n\
129 \n\
130  -o\n\
131  Use Ogre3D for visibility tests.\n\
132 \n\
133  -w\n\
134  When Ogre3D is enable [-o] show Ogre3D configuration dialog thatallows to set the renderer.\n\
135 \n\
136  -l\n\
137  Use the scanline for visibility tests.\n\
138 \n\
139  -v\n\
140  Compute covariance matrix.\n\
141 \n\
142  -v\n\
143  Compute gradient projection error.\n\
144 \n\
145  -h \n\
146  Print the help.\n\n");
147 
148  if (badparam)
149  fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
150 }
151 
152 
153 bool getOptions(int argc, const char **argv, std::string &ipath, std::string &configFile, std::string &modelFile,
154  std::string &initFile, bool &displayFeatures, bool &click_allowed, bool &display,
155  bool& cao3DModel, bool& trackCylinder, bool &useOgre, bool &showOgreConfigDialog,
156  bool &useScanline, bool &computeCovariance, bool &projectionError)
157 {
158  const char *optarg_;
159  int c;
160  while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) {
161 
162  switch (c) {
163  case 'i': ipath = optarg_; break;
164  case 'x': configFile = optarg_; break;
165  case 'm': modelFile = optarg_; break;
166  case 'n': initFile = optarg_; break;
167  case 't': displayFeatures = false; break;
168  case 'f': cao3DModel = true; break;
169  case 'c': click_allowed = false; break;
170  case 'd': display = false; break;
171  case 'C': trackCylinder = false; break;
172  case 'o': useOgre = true; break;
173  case 'l': useScanline = true; break;
174  case 'w': showOgreConfigDialog = true; break;
175  case 'v': computeCovariance = true; break;
176  case 'p': projectionError = true; break;
177  case 'h': usage(argv[0], NULL); return false; break;
178 
179  default:
180  usage(argv[0], optarg_);
181  return false; break;
182  }
183  }
184 
185  if ((c == 1) || (c == -1)) {
186  // standalone param or error
187  usage(argv[0], NULL);
188  std::cerr << "ERROR: " << std::endl;
189  std::cerr << " Bad argument " << optarg_ << std::endl << std::endl;
190  return false;
191  }
192 
193  return true;
194 }
195 
196 int
197 main(int argc, const char ** argv)
198 {
199  try {
200  std::string env_ipath;
201  std::string opt_ipath;
202  std::string ipath;
203  std::string opt_configFile;
204  std::string configFile;
205  std::string opt_modelFile;
206  std::string modelFile;
207  std::string opt_initFile;
208  std::string initFile;
209  bool displayFeatures = true;
210  bool opt_click_allowed = true;
211  bool opt_display = true;
212  bool cao3DModel = false;
213  bool trackCylinder = true;
214  bool useOgre = false;
215  bool showOgreConfigDialog = false;
216  bool useScanline = false;
217  bool computeCovariance = false;
218  bool projectionError = false;
219  bool quit = false;
220 
221  // Get the visp-images-data package path or VISP_INPUT_IMAGE_PATH environment variable value
222  env_ipath = vpIoTools::getViSPImagesDataPath();
223 
224  // Set the default input path
225  if (! env_ipath.empty())
226  ipath = env_ipath;
227 
228 
229  // Read the command line options
230  if (!getOptions(argc, argv, opt_ipath, opt_configFile, opt_modelFile, opt_initFile, displayFeatures,
231  opt_click_allowed, opt_display, cao3DModel, trackCylinder, useOgre, showOgreConfigDialog,
232  useScanline, computeCovariance, projectionError)) {
233  return (-1);
234  }
235 
236  // Test if an input path is set
237  if (opt_ipath.empty() && env_ipath.empty() ){
238  usage(argv[0], NULL);
239  std::cerr << std::endl
240  << "ERROR:" << std::endl;
241  std::cerr << " Use -i <visp image path> option or set VISP_INPUT_IMAGE_PATH "
242  << std::endl
243  << " environment variable to specify the location of the " << std::endl
244  << " image path where test images are located." << std::endl
245  << std::endl;
246 
247  return (-1);
248  }
249 
250  // Get the option values
251  if (!opt_ipath.empty())
252  ipath = vpIoTools::createFilePath(opt_ipath, "ViSP-images/mbt/cube/image%04d.pgm");
253  else
254  ipath = vpIoTools::createFilePath(env_ipath, "ViSP-images/mbt/cube/image%04d.pgm");
255 
256  if (!opt_configFile.empty())
257  configFile = opt_configFile;
258  else if (!opt_ipath.empty())
259  configFile = vpIoTools::createFilePath(opt_ipath, "ViSP-images/mbt/cube.xml");
260  else
261  configFile = vpIoTools::createFilePath(env_ipath, "ViSP-images/mbt/cube.xml");
262 
263  if (!opt_modelFile.empty()){
264  modelFile = opt_modelFile;
265  }else{
266  std::string modelFileCao;
267  std::string modelFileWrl;
268  if(trackCylinder){
269  modelFileCao = "ViSP-images/mbt/cube_and_cylinder.cao";
270  modelFileWrl = "ViSP-images/mbt/cube_and_cylinder.wrl";
271  }else{
272  modelFileCao = "ViSP-images/mbt/cube.cao";
273  modelFileWrl = "ViSP-images/mbt/cube.wrl";
274  }
275 
276  if(!opt_ipath.empty()){
277  if(cao3DModel){
278  modelFile = vpIoTools::createFilePath(opt_ipath, modelFileCao);
279  }
280  else{
281 #ifdef VISP_HAVE_COIN3D
282  modelFile = vpIoTools::createFilePath(opt_ipath, modelFileWrl);
283 #else
284  std::cerr << "Coin is not detected in ViSP. Use the .cao model instead." << std::endl;
285  modelFile = vpIoTools::createFilePath(opt_ipath, modelFileCao);
286 #endif
287  }
288  }
289  else{
290  if(cao3DModel){
291  modelFile = vpIoTools::createFilePath(env_ipath, modelFileCao);
292  }
293  else{
294 #ifdef VISP_HAVE_COIN3D
295  modelFile = vpIoTools::createFilePath(env_ipath, modelFileWrl);
296 #else
297  std::cerr << "Coin is not detected in ViSP. Use the .cao model instead." << std::endl;
298  modelFile = vpIoTools::createFilePath(env_ipath, modelFileCao);
299 #endif
300  }
301  }
302  }
303 
304  if (!opt_initFile.empty())
305  initFile = opt_initFile;
306  else if (!opt_ipath.empty())
307  initFile = vpIoTools::createFilePath(opt_ipath, "ViSP-images/mbt/cube");
308  else
309  initFile = vpIoTools::createFilePath(env_ipath, "ViSP-images/mbt/cube");
310 
312  vpVideoReader reader;
313 
314  reader.setFileName(ipath);
315  try{
316  reader.open(I);
317  }catch(...){
318  std::cout << "Cannot open sequence: " << ipath << std::endl;
319  return -1;
320  }
321 
322  reader.acquire(I);
323 
324  // initialise a display
325 #if defined VISP_HAVE_X11
326  vpDisplayX display;
327 #elif defined VISP_HAVE_GDI
328  vpDisplayGDI display;
329 #elif defined VISP_HAVE_OPENCV
330  vpDisplayOpenCV display;
331 #elif defined VISP_HAVE_D3D9
332  vpDisplayD3D display;
333 #elif defined VISP_HAVE_GTK
334  vpDisplayGTK display;
335 #else
336  opt_display = false;
337 #endif
338  if (opt_display)
339  {
340 #if (defined VISP_HAVE_DISPLAY)
341  display.init(I, 100, 100, "Test tracking") ;
342 #endif
343  vpDisplay::display(I) ;
344  vpDisplay::flush(I);
345  }
346 
347  vpMbEdgeTracker tracker;
349 
350  // Initialise the tracker: camera parameters, moving edge and KLT settings
351  vpCameraParameters cam;
352 #if defined (VISP_HAVE_XML2)
353  // From the xml file
354  tracker.loadConfigFile(configFile);
355 #else
356  // By setting the parameters:
357  cam.initPersProjWithoutDistortion(547, 542, 338, 234);
358 
359  vpMe me;
360  me.setMaskSize(5);
361  me.setMaskNumber(180);
362  me.setRange(7);
363  me.setThreshold(5000);
364  me.setMu1(0.5);
365  me.setMu2(0.5);
366  me.setSampleStep(4);
367 
368  tracker.setCameraParameters(cam);
369  tracker.setMovingEdge(me);
370 
371  // Specify the clipping to use
372  tracker.setNearClippingDistance(0.01);
373  tracker.setFarClippingDistance(0.90);
375  // tracker.setClipping(tracker.getClipping() | vpMbtPolygon::LEFT_CLIPPING | vpMbtPolygon::RIGHT_CLIPPING | vpMbtPolygon::UP_CLIPPING | vpMbtPolygon::DOWN_CLIPPING); // Equivalent to FOV_CLIPPING
376 #endif
377 
378  // Display the moving edges, see documentation for the signification of the colours
379  tracker.setDisplayFeatures(displayFeatures);
380 
381  // Tells if the tracker has to use Ogre3D for visibility tests
382  tracker.setOgreVisibilityTest(useOgre);
383  if (useOgre)
384  tracker.setOgreShowConfigDialog(showOgreConfigDialog);
385 
386  // Tells if the tracker has to use the scanline visibility tests
387  tracker.setScanLineVisibilityTest(useScanline);
388 
389  // Tells if the tracker has to compute the covariance matrix
390  tracker.setCovarianceComputation(computeCovariance);
391 
392  // Tells if the tracker has to compute the projection error
393  tracker.setProjectionErrorComputation(projectionError);
394 
395  // Retrieve the camera parameters from the tracker
396  tracker.getCameraParameters(cam);
397 
398  // Loop to position the cube
399  if (opt_display && opt_click_allowed)
400  {
401  while(!vpDisplay::getClick(I,false)){
403  vpDisplay::displayText(I, 15, 10, "click after positioning the object", vpColor::red);
404  vpDisplay::flush(I) ;
405  }
406  }
407 
408  // Load the 3D model (either a vrml file or a .cao file)
409  tracker.loadModel(modelFile);
410 
411  // Initialise the tracker by clicking on the image
412  // This function looks for
413  // - a ./cube/cube.init file that defines the 3d coordinates (in meter, in the object basis) of the points used for the initialisation
414  // - a ./cube/cube.ppm file to display where the user have to click (optionnal, set by the third parameter)
415  if (opt_display && opt_click_allowed)
416  {
417  tracker.initClick(I, initFile, true);
418  tracker.getPose(cMo);
419  // display the 3D model at the given pose
420  tracker.display(I,cMo, cam, vpColor::red);
421  }
422  else
423  {
424  vpHomogeneousMatrix cMoi(0.02044769891, 0.1101505452, 0.5078963719, 2.063603907, 1.110231561, -0.4392789872);
425  tracker.initFromPose(I, cMoi);
426  }
427 
428  //track the model
429  tracker.track(I);
430  tracker.getPose(cMo);
431 
432  if (opt_display)
433  vpDisplay::flush(I);
434 
435  while (!reader.end())
436  {
437  // acquire a new image
438  reader.acquire(I);
439  // display the image
440  if (opt_display)
442 
443  // Test to reset the tracker
444  if (reader.getFrameIndex() == reader.getFirstFrameIndex() + 10) {
445  vpTRACE("Test reset tracker");
446  if (opt_display)
448  tracker.resetTracker();
449 #if defined (VISP_HAVE_XML2)
450  tracker.loadConfigFile(configFile);
451 #else
452  // By setting the parameters:
453  cam.initPersProjWithoutDistortion(547, 542, 338, 234);
454 
455  vpMe me;
456  me.setMaskSize(5);
457  me.setMaskNumber(180);
458  me.setRange(7);
459  me.setThreshold(5000);
460  me.setMu1(0.5);
461  me.setMu2(0.5);
462  me.setSampleStep(4);
463 
464  tracker.setCameraParameters(cam);
465  tracker.setMovingEdge(me);
466 
467  // Specify the clipping to use
468  tracker.setNearClippingDistance(0.01);
469  tracker.setFarClippingDistance(0.90);
471  // tracker.setClipping(tracker.getClipping() | vpMbtPolygon::LEFT_CLIPPING | vpMbtPolygon::RIGHT_CLIPPING | vpMbtPolygon::UP_CLIPPING | vpMbtPolygon::DOWN_CLIPPING); // Equivalent to FOV_CLIPPING
472 #endif
473  tracker.loadModel(modelFile);
474  tracker.setCameraParameters(cam);
475  tracker.setOgreVisibilityTest(useOgre);
476  tracker.setScanLineVisibilityTest(useScanline);
477  tracker.setCovarianceComputation(computeCovariance);
478  tracker.setProjectionErrorComputation(projectionError);
479  tracker.initFromPose(I, cMo);
480  }
481 
482  // Test to set an initial pose
483  if (reader.getFrameIndex() == reader.getFirstFrameIndex() + 50) {
484  cMo.buildFrom(0.0439540832, 0.0845870108, 0.5477322481, 2.179498458, 0.8611798108, -0.3491961946);
485  vpTRACE("Test set pose");
486  tracker.setPose(I, cMo);
487 // if (opt_display) {
488 // // display the 3D model
489 // tracker.display(I, cMo, cam, vpColor::darkRed);
490 // // display the frame
491 // vpDisplay::displayFrame (I, cMo, cam, 0.05);
496 // }
497  }
498 
499  // track the object: stop tracking from frame 40 to 50
500  if (reader.getFrameIndex() - reader.getFirstFrameIndex() < 40 || reader.getFrameIndex() - reader.getFirstFrameIndex() >= 50) {
501  tracker.track(I);
502  tracker.getPose(cMo);
503  if (opt_display) {
504  // display the 3D model
505  tracker.display(I, cMo, cam, vpColor::darkRed);
506  // display the frame
507  vpDisplay::displayFrame (I, cMo, cam, 0.05);
508  }
509  }
510 
511  if (opt_click_allowed) {
512  vpDisplay::displayText(I, 10, 10, "Click to quit", vpColor::red);
513  if (vpDisplay::getClick(I, false)) {
514  quit = true;
515  break;
516  }
517  }
518 
519  if(computeCovariance) {
520  std::cout << "Covariance matrix: \n" << tracker.getCovarianceMatrix() << std::endl << std::endl;
521  }
522 
523  if(projectionError) {
524  std::cout << "Projection error: " << tracker.getProjectionError() << std::endl << std::endl;
525  }
526 
527  vpDisplay::flush(I) ;
528  }
529 
530  if (opt_click_allowed && !quit) {
532  }
533  reader.close();
534 
535 #if defined (VISP_HAVE_XML2)
536  // Cleanup memory allocated by xml library used to parse the xml config file in vpMbEdgeTracker::loadConfigFile()
538 #endif
539 
540 #if defined(VISP_HAVE_COIN3D) && (COIN_MAJOR_VERSION == 3)
541  // Cleanup memory allocated by Coin library used to load a vrml model in vpMbEdgeTracker::loadModel()
542  // We clean only if Coin was used.
543  if(! cao3DModel)
544  SoDB::finish();
545 #endif
546 
547  return 0;
548  }
549  catch(vpException &e) {
550  std::cout << "Catch an exception: " << e << std::endl;
551  return 1;
552  }
553 }
554 
555 #else
556 
557 int main()
558 {
559  std::cout << "visp_mbt module is required to run this example." << std::endl;
560  return 0;
561 }
562 
563 #endif
564 
virtual unsigned int getClipping() const
Definition: vpMbTracker.h:208
virtual void setDisplayFeatures(const bool displayF)
Definition: vpMbTracker.h:411
virtual void setCovarianceComputation(const bool &flag)
Definition: vpMbTracker.h:398
void setMovingEdge(const vpMe &me)
virtual void getPose(vpHomogeneousMatrix &cMo_) const
Definition: vpMbTracker.h:333
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
static std::string getViSPImagesDataPath()
Definition: vpIoTools.cpp:1157
Implementation of an homogeneous matrix and operations on such kind of matrices.
void track(const vpImage< unsigned char > &I)
void setMaskNumber(const unsigned int &a)
Definition: vpMe.cpp:488
static const vpColor darkRed
Definition: vpColor.h:164
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:128
void setSampleStep(const double &s)
Definition: vpMe.h:263
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...
virtual double getProjectionError() const
Definition: vpMbTracker.h:226
error that can be emited by ViSP classes.
Definition: vpException.h:73
Definition: vpMe.h:59
Make the complete tracking of an object by using its CAD model.
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
virtual void setCameraParameters(const vpCameraParameters &camera)
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
void loadConfigFile(const std::string &configFile)
static void flush(const vpImage< unsigned char > &I)
void setMu1(const double &mu_1)
Definition: vpMe.h:226
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
Definition: vpParseArgv.cpp:76
static const vpColor red
Definition: vpColor.h:163
void initPersProjWithoutDistortion(const double px, const double py, const double u0, const double v0)
virtual void setNearClippingDistance(const double &dist)
virtual void setOgreVisibilityTest(const bool &v)
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
virtual void setScanLineVisibilityTest(const bool &v)
void setMaskSize(const unsigned int &a)
Definition: vpMe.cpp:496
#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)
virtual void setFarClippingDistance(const double &dist)
long getFirstFrameIndex() const
void setFileName(const char *filename)
virtual void initClick(const vpImage< unsigned char > &I, const std::string &initFile, const bool displayHelp=false)
void buildFrom(const vpTranslationVector &t, const vpRotationMatrix &R)
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 setMu2(const double &mu_2)
Definition: vpMe.h:233
long getFrameIndex() const
virtual void loadModel(const char *modelFile, const bool verbose=false)
virtual void getCameraParameters(vpCameraParameters &camera) const
Definition: vpMbTracker.h:201
virtual vpMatrix getCovarianceMatrix() const
Definition: vpMbTracker.h:213
void setThreshold(const double &t)
Definition: vpMe.h:284
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)
void setRange(const unsigned int &r)
Definition: vpMe.h:256
virtual void setClipping(const unsigned int &flags)
virtual void setProjectionErrorComputation(const bool &flag)
Definition: vpMbTracker.h:437