Visual Servoing Platform  version 3.2.0
vpMbDepthDenseTracker.cpp
1 /****************************************************************************
2  *
3  * ViSP, open source Visual Servoing Platform software.
4  * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5  *
6  * This software is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  * See the file LICENSE.txt at the root directory of this source
11  * distribution for additional information about the GNU GPL.
12  *
13  * For using ViSP with software that can not be combined with the GNU
14  * GPL, please contact Inria about acquiring a ViSP Professional
15  * Edition License.
16  *
17  * See http://visp.inria.fr for more information.
18  *
19  * This software was developed at:
20  * Inria Rennes - Bretagne Atlantique
21  * Campus Universitaire de Beaulieu
22  * 35042 Rennes Cedex
23  * France
24  *
25  * If you have questions regarding the use of this file, please contact
26  * Inria at visp@inria.fr
27  *
28  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30  *
31  * Description:
32  * Model-based tracker using depth dense features.
33  *
34  *****************************************************************************/
35 
36 #include <iostream>
37 
38 #include <visp3/core/vpConfig.h>
39 
40 #ifdef VISP_HAVE_PCL
41 #include <pcl/point_cloud.h>
42 #endif
43 
44 #include <visp3/core/vpDisplay.h>
45 #include <visp3/core/vpExponentialMap.h>
46 #include <visp3/core/vpTrackingException.h>
47 #include <visp3/mbt/vpMbDepthDenseTracker.h>
48 #include <visp3/mbt/vpMbtXmlGenericParser.h>
49 
50 #if DEBUG_DISPLAY_DEPTH_DENSE
51 #include <visp3/gui/vpDisplayGDI.h>
52 #include <visp3/gui/vpDisplayX.h>
53 #endif
54 
56  : m_depthDenseHiddenFacesDisplay(), m_depthDenseI_dummyVisibility(), m_depthDenseListOfActiveFaces(),
57  m_denseDepthNbFeatures(0), m_depthDenseFaces(), m_depthDenseSamplingStepX(2), m_depthDenseSamplingStepY(2),
58  m_error_depthDense(), m_L_depthDense(), m_robust_depthDense(), m_w_depthDense(), m_weightedError_depthDense()
59 #if DEBUG_DISPLAY_DEPTH_DENSE
60  ,
61  m_debugDisp_depthDense(NULL), m_debugImage_depthDense()
62 #endif
63 {
64 #ifdef VISP_HAVE_OGRE
65  faces.getOgreContext()->setWindowName("MBT Depth Dense");
66 #endif
67 
68 #if defined(VISP_HAVE_X11) && DEBUG_DISPLAY_DEPTH_DENSE
69  m_debugDisp_depthDense = new vpDisplayX;
70 #elif defined(VISP_HAVE_GDI) && DEBUG_DISPLAY_DEPTH_DENSE
71  m_debugDisp_depthDense = new vpDisplayGDI;
72 #endif
73 }
74 
76 {
77  for (size_t i = 0; i < m_depthDenseFaces.size(); i++) {
78  delete m_depthDenseFaces[i];
79  }
80 
81 #if DEBUG_DISPLAY_DEPTH_DENSE
82  delete m_debugDisp_depthDense;
83 #endif
84 }
85 
86 void vpMbDepthDenseTracker::addFace(vpMbtPolygon &polygon, const bool alreadyClose)
87 {
88  if (polygon.nbpt < 3) {
89  return;
90  }
91 
92  // Copy hidden faces
94 
95  vpMbtFaceDepthDense *normal_face = new vpMbtFaceDepthDense;
96  normal_face->m_hiddenFace = &faces;
97  normal_face->m_polygon = &polygon;
98  normal_face->m_cam = cam;
99  normal_face->m_useScanLine = useScanLine;
100  normal_face->m_clippingFlag = clippingFlag;
101  normal_face->m_distNearClip = distNearClip;
102  normal_face->m_distFarClip = distFarClip;
103 
104  // Add lines that compose the face
105  unsigned int nbpt = polygon.getNbPoint();
106  if (nbpt > 0) {
107  for (unsigned int i = 0; i < nbpt - 1; i++) {
108  normal_face->addLine(polygon.p[i], polygon.p[i + 1], &m_depthDenseHiddenFacesDisplay, polygon.getIndex(),
109  polygon.getName());
110  }
111 
112  if (!alreadyClose) {
113  // Add last line that closes the face
114  normal_face->addLine(polygon.p[nbpt - 1], polygon.p[0], &m_depthDenseHiddenFacesDisplay, polygon.getIndex(),
115  polygon.getName());
116  }
117  }
118 
119  // Construct a vpPlane in object frame
120  vpPoint pts[3];
121  pts[0] = polygon.p[0];
122  pts[1] = polygon.p[1];
123  pts[2] = polygon.p[2];
124  normal_face->m_planeObject = vpPlane(pts[0], pts[1], pts[2], vpPlane::object_frame);
125 
126  m_depthDenseFaces.push_back(normal_face);
127 }
128 
129 void vpMbDepthDenseTracker::computeVisibility(const unsigned int width, const unsigned int height)
130 {
131  m_depthDenseI_dummyVisibility.resize(height, width);
132 
133  bool changed = false;
135 
136  if (useScanLine) {
137  // if (clippingFlag <= 2) {
138  // cam.computeFov(m_depthDenseI_dummyVisibility.getWidth(),
139  // m_depthDenseI_dummyVisibility.getHeight());
140  // }
141 
145  }
146 
147  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
148  it != m_depthDenseFaces.end(); ++it) {
149  vpMbtFaceDepthDense *face_normal = *it;
150  face_normal->computeVisibility();
151  }
152 }
153 
155 {
156  double normRes = 0;
157  double normRes_1 = -1;
158  unsigned int iter = 0;
159 
160  computeVVSInit();
161 
163  vpMatrix LTL;
164  vpColVector LTR, v;
165 
166  double mu = m_initialMu;
167  vpHomogeneousMatrix cMo_prev;
168 
169  bool isoJoIdentity_ = true;
171  vpMatrix L_true, LVJ_true;
172 
173  while (std::fabs(normRes_1 - normRes) > m_stopCriteriaEpsilon && (iter < m_maxIter)) {
175 
176  bool reStartFromLastIncrement = false;
177  computeVVSCheckLevenbergMarquardt(iter, m_error_depthDense, error_prev, cMo_prev, mu, reStartFromLastIncrement);
178 
179  if (!reStartFromLastIncrement) {
181 
182  if (computeCovariance) {
183  L_true = m_L_depthDense;
184  if (!isoJoIdentity_) {
186  cVo.buildFrom(cMo);
187  LVJ_true = (m_L_depthDense * cVo * oJo);
188  }
189  }
190 
191  // Compute DoF only once
192  if (iter == 0) {
193  isoJoIdentity_ = true;
194  oJo.eye();
195 
196  // If all the 6 dof should be estimated, we check if the interaction
197  // matrix is full rank. If not we remove automatically the dof that
198  // cannot be estimated This is particularly useful when consering
199  // circles (rank 5) and cylinders (rank 4)
200  if (isoJoIdentity_) {
201  cVo.buildFrom(cMo);
202 
203  vpMatrix K; // kernel
204  unsigned int rank = (m_L_depthDense * cVo).kernel(K);
205  if (rank == 0) {
206  throw vpException(vpException::fatalError, "Rank=0, cannot estimate the pose !");
207  }
208 
209  if (rank != 6) {
210  vpMatrix I; // Identity
211  I.eye(6);
212  oJo = I - K.AtA();
213 
214  isoJoIdentity_ = false;
215  }
216  }
217  }
218 
219  double num = 0.0, den = 0.0;
220  for (unsigned int i = 0; i < m_L_depthDense.getRows(); i++) {
221  // Compute weighted errors and stop criteria
224  den += m_w_depthDense[i];
225 
226  // weight interaction matrix
227  for (unsigned int j = 0; j < 6; j++) {
228  m_L_depthDense[i][j] *= m_w_depthDense[i];
229  }
230  }
231 
233  m_error_depthDense, error_prev, LTR, mu, v);
234 
235  cMo_prev = cMo;
237 
238  normRes_1 = normRes;
239  normRes = sqrt(num / den);
240  }
241 
242  iter++;
243  }
244 
245  computeCovarianceMatrixVVS(isoJoIdentity_, m_w_depthDense, cMo_prev, L_true, LVJ_true, m_error_depthDense);
246 }
247 
249 {
251 
252  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseListOfActiveFaces.begin();
253  it != m_depthDenseListOfActiveFaces.end(); ++it) {
254  vpMbtFaceDepthDense *face = *it;
256  }
257 
258  m_L_depthDense.resize(m_denseDepthNbFeatures, 6, false, false);
261 
263  m_w_depthDense = 1;
264 }
265 
267 {
268  unsigned int start_index = 0;
269  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseListOfActiveFaces.begin();
270  it != m_depthDenseListOfActiveFaces.end(); ++it) {
271  vpMbtFaceDepthDense *face = *it;
272 
273  vpMatrix L_face;
274  vpColVector error;
275 
276  face->computeInteractionMatrixAndResidu(cMo, L_face, error);
277 
278  m_error_depthDense.insert(start_index, error);
279  m_L_depthDense.insert(L_face, start_index, 0);
280 
281  start_index += error.getRows();
282  }
283 }
284 
286 {
288 }
289 
291  const vpCameraParameters &cam_, const vpColor &col, const unsigned int thickness,
292  const bool displayFullModel)
293 {
294  vpCameraParameters c = cam_;
295 
296  bool changed = false;
298 
299  if (useScanLine) {
300  c.computeFov(I.getWidth(), I.getHeight());
301 
304  }
305 
306  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
307  it != m_depthDenseFaces.end(); ++it) {
308  vpMbtFaceDepthDense *face_normal = *it;
309  face_normal->display(I, cMo_, c, col, thickness, displayFullModel);
310 
311  if (displayFeatures) {
312  face_normal->displayFeature(I, cMo_, c, 0.05, thickness);
313  }
314  }
315 }
316 
318  const vpCameraParameters &cam_, const vpColor &col, const unsigned int thickness,
319  const bool displayFullModel)
320 {
321  vpCameraParameters c = cam_;
322 
323  bool changed = false;
324  vpImage<unsigned char> I_dummy;
325  vpImageConvert::convert(I, I_dummy);
327 
328  if (useScanLine) {
329  c.computeFov(I.getWidth(), I.getHeight());
330 
333  }
334 
335  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
336  it != m_depthDenseFaces.end(); ++it) {
337  vpMbtFaceDepthDense *face_normal = *it;
338  face_normal->display(I, cMo_, c, col, thickness, displayFullModel);
339 
340  if (displayFeatures) {
341  face_normal->displayFeature(I, cMo_, c, 0.05, thickness);
342  }
343  }
344 }
345 
347 {
348  if (!modelInitialised) {
349  throw vpException(vpException::fatalError, "model not initialized");
350  }
351 
352  bool reInitialisation = false;
353  if (!useOgre) {
354  faces.setVisible(I, cam, cMo, angleAppears, angleDisappears, reInitialisation);
355  } else {
356 #ifdef VISP_HAVE_OGRE
357  if (!faces.isOgreInitialised()) {
360  faces.initOgre(cam);
361  // Turn off Ogre config dialog display for the next call to this
362  // function since settings are saved in the ogre.cfg file and used
363  // during the next call
364  ogreShowConfigDialog = false;
365  }
366 
367  faces.setVisibleOgre(I, cam, cMo, angleAppears, angleDisappears, reInitialisation);
368 #else
369  faces.setVisible(I, cam, cMo, angleAppears, angleDisappears, reInitialisation);
370 #endif
371  }
372 
373  if (useScanLine || clippingFlag > 3)
374  cam.computeFov(I.getWidth(), I.getHeight());
375 
377 }
378 
379 void vpMbDepthDenseTracker::loadConfigFile(const std::string &configFile)
380 {
381 #ifdef VISP_HAVE_XML2
383 
384  xmlp.setCameraParameters(cam);
387 
390 
391  try {
392  std::cout << " *********** Parsing XML for Mb Depth Dense Tracker ************ " << std::endl;
393  xmlp.parse(configFile);
394  } catch (const vpException &e) {
395  std::cerr << "Exception: " << e.what() << std::endl;
396  throw vpException(vpException::ioError, "Cannot open XML file \"%s\"", configFile.c_str());
397  }
398 
399  vpCameraParameters camera;
400  xmlp.getCameraParameters(camera);
401  setCameraParameters(camera);
402 
405 
406  if (xmlp.hasNearClippingDistance())
408 
409  if (xmlp.hasFarClippingDistance())
411 
412  if (xmlp.getFovClipping())
414 
416 #else
417  std::cerr << "You need the libXML2 to read the config file " << configFile << std::endl;
418 #endif
419 }
420 
421 void vpMbDepthDenseTracker::reInitModel(const vpImage<unsigned char> &I, const std::string &cad_name,
422  const vpHomogeneousMatrix &cMo_, const bool verbose)
423 {
424  cMo.eye();
425 
426  for (size_t i = 0; i < m_depthDenseFaces.size(); i++) {
427  delete m_depthDenseFaces[i];
428  m_depthDenseFaces[i] = NULL;
429  }
430 
431  m_depthDenseFaces.clear();
432 
433  loadModel(cad_name, verbose);
434  initFromPose(I, cMo_);
435 }
436 
437 #if defined(VISP_HAVE_PCL)
438 void vpMbDepthDenseTracker::reInitModel(const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &point_cloud,
439  const std::string &cad_name, const vpHomogeneousMatrix &cMo_,
440  const bool verbose)
441 {
442  vpImage<unsigned char> I_dummy(point_cloud->height, point_cloud->width);
443  reInitModel(I_dummy, cad_name, cMo_, verbose);
444 }
445 
446 #endif
447 
449 {
450  cMo.eye();
451 
452  for (std::vector<vpMbtFaceDepthDense *>::iterator it = m_depthDenseFaces.begin();
453  it != m_depthDenseFaces.end(); ++it) {
454  vpMbtFaceDepthDense *normal_face = *it;
455  delete normal_face;
456  normal_face = NULL;
457  }
458 
459  m_depthDenseFaces.clear();
460 
461  m_computeInteraction = true;
462  computeCovariance = false;
463 
466 
468 
469  m_lambda = 1.0;
470  m_maxIter = 30;
471 
472  faces.reset();
473 
475 
476  useScanLine = false;
477 
478 #ifdef VISP_HAVE_OGRE
479  useOgre = false;
480 #endif
481 
483 }
484 
486 {
488 #ifdef VISP_HAVE_OGRE
489  faces.getOgreContext()->setWindowName("MBT Depth Dense");
490 #endif
491 }
492 
494 {
495  cMo = cdMo;
496  init(I);
497 }
498 
499 #if defined(VISP_HAVE_PCL)
500 void vpMbDepthDenseTracker::setPose(const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &point_cloud,
501  const vpHomogeneousMatrix &cdMo)
502 {
503  vpImage<unsigned char> I_dummy(point_cloud->height, point_cloud->width);
504  cMo = cdMo;
505  init(I_dummy);
506 }
507 #endif
508 
510 {
512 
513  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
514  it != m_depthDenseFaces.end(); ++it) {
515  (*it)->setScanLineVisibilityTest(v);
516  }
517 }
518 
519 void vpMbDepthDenseTracker::setUseDepthDenseTracking(const std::string &name, const bool &useDepthDenseTracking)
520 {
521  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
522  it != m_depthDenseFaces.end(); ++it) {
523  vpMbtFaceDepthDense *face = *it;
524  if (face->m_polygon->getName() == name) {
525  face->setTracked(useDepthDenseTracking);
526  }
527  }
528 }
529 
531 
532 #ifdef VISP_HAVE_PCL
533 void vpMbDepthDenseTracker::segmentPointCloud(const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &point_cloud)
534 {
536 
537 #if DEBUG_DISPLAY_DEPTH_DENSE
538  if (!m_debugDisp_depthDense->isInitialised()) {
539  m_debugImage_depthDense.resize(point_cloud->height, point_cloud->width);
540  m_debugDisp_depthDense->init(m_debugImage_depthDense, 50, 0, "Debug display dense depth tracker");
541  }
542 
543  m_debugImage_depthDense = 0;
544  std::vector<std::vector<vpImagePoint> > roiPts_vec;
545 #endif
546 
547  for (std::vector<vpMbtFaceDepthDense *>::iterator it = m_depthDenseFaces.begin();
548  it != m_depthDenseFaces.end(); ++it) {
549  vpMbtFaceDepthDense *face = *it;
550 
551  if (face->isVisible() && face->isTracked()) {
552 #if DEBUG_DISPLAY_DEPTH_DENSE
553  std::vector<std::vector<vpImagePoint> > roiPts_vec_;
554 #endif
556 #if DEBUG_DISPLAY_DEPTH_DENSE
557  ,
558  m_debugImage_depthDense, roiPts_vec_
559 #endif
560  , m_mask
561  )) {
562  m_depthDenseListOfActiveFaces.push_back(*it);
563 
564 #if DEBUG_DISPLAY_DEPTH_DENSE
565  roiPts_vec.insert(roiPts_vec.end(), roiPts_vec_.begin(), roiPts_vec_.end());
566 #endif
567  }
568  }
569  }
570 
571 #if DEBUG_DISPLAY_DEPTH_DENSE
572  vpDisplay::display(m_debugImage_depthDense);
573 
574  for (size_t i = 0; i < roiPts_vec.size(); i++) {
575  if (roiPts_vec[i].empty())
576  continue;
577 
578  for (size_t j = 0; j < roiPts_vec[i].size() - 1; j++) {
579  vpDisplay::displayLine(m_debugImage_depthDense, roiPts_vec[i][j], roiPts_vec[i][j + 1], vpColor::red, 2);
580  }
581  vpDisplay::displayLine(m_debugImage_depthDense, roiPts_vec[i][0], roiPts_vec[i][roiPts_vec[i].size() - 1],
582  vpColor::red, 2);
583  }
584 
585  vpDisplay::flush(m_debugImage_depthDense);
586 #endif
587 }
588 #endif
589 
590 void vpMbDepthDenseTracker::segmentPointCloud(const std::vector<vpColVector> &point_cloud, const unsigned int width,
591  const unsigned int height)
592 {
594 
595 #if DEBUG_DISPLAY_DEPTH_DENSE
596  if (!m_debugDisp_depthDense->isInitialised()) {
597  m_debugImage_depthDense.resize(height, width);
598  m_debugDisp_depthDense->init(m_debugImage_depthDense, 50, 0, "Debug display dense depth tracker");
599  }
600 
601  m_debugImage_depthDense = 0;
602  std::vector<std::vector<vpImagePoint> > roiPts_vec;
603 #endif
604 
605  for (std::vector<vpMbtFaceDepthDense *>::iterator it = m_depthDenseFaces.begin();
606  it != m_depthDenseFaces.end(); ++it) {
607  vpMbtFaceDepthDense *face = *it;
608 
609  if (face->isVisible() && face->isTracked()) {
610 #if DEBUG_DISPLAY_DEPTH_DENSE
611  std::vector<std::vector<vpImagePoint> > roiPts_vec_;
612 #endif
613  if (face->computeDesiredFeatures(cMo, width, height, point_cloud, m_depthDenseSamplingStepX,
615 #if DEBUG_DISPLAY_DEPTH_DENSE
616  ,
617  m_debugImage_depthDense, roiPts_vec_
618 #endif
619  , m_mask
620  )) {
621  m_depthDenseListOfActiveFaces.push_back(*it);
622 
623 #if DEBUG_DISPLAY_DEPTH_DENSE
624  roiPts_vec.insert(roiPts_vec.end(), roiPts_vec_.begin(), roiPts_vec_.end());
625 #endif
626  }
627  }
628  }
629 
630 #if DEBUG_DISPLAY_DEPTH_DENSE
631  vpDisplay::display(m_debugImage_depthDense);
632 
633  for (size_t i = 0; i < roiPts_vec.size(); i++) {
634  if (roiPts_vec[i].empty())
635  continue;
636 
637  for (size_t j = 0; j < roiPts_vec[i].size() - 1; j++) {
638  vpDisplay::displayLine(m_debugImage_depthDense, roiPts_vec[i][j], roiPts_vec[i][j + 1], vpColor::red, 2);
639  }
640  vpDisplay::displayLine(m_debugImage_depthDense, roiPts_vec[i][0], roiPts_vec[i][roiPts_vec[i].size() - 1],
641  vpColor::red, 2);
642  }
643 
644  vpDisplay::flush(m_debugImage_depthDense);
645 #endif
646 }
647 
649 {
650  this->cam = camera;
651 
652  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
653  it != m_depthDenseFaces.end(); ++it) {
654  (*it)->setCameraParameters(camera);
655  }
656 }
657 
659 {
660  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
661  it != m_depthDenseFaces.end(); ++it) {
662  (*it)->setDepthDenseFilteringMaxDistance(maxDistance);
663  }
664 }
665 
667 {
668  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
669  it != m_depthDenseFaces.end(); ++it) {
670  (*it)->setDepthDenseFilteringMethod(method);
671  }
672 }
673 
675 {
676  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
677  it != m_depthDenseFaces.end(); ++it) {
678  (*it)->setDepthDenseFilteringMinDistance(minDistance);
679  }
680 }
681 
682 void vpMbDepthDenseTracker::setDepthDenseFilteringOccupancyRatio(const double occupancyRatio)
683 {
684  if (occupancyRatio < 0.0 || occupancyRatio > 1.0) {
685  std::cerr << "occupancyRatio < 0.0 || occupancyRatio > 1.0" << std::endl;
686  return;
687  }
688 
689  for (std::vector<vpMbtFaceDepthDense *>::const_iterator it = m_depthDenseFaces.begin();
690  it != m_depthDenseFaces.end(); ++it) {
691  (*it)->setDepthDenseFilteringOccupancyRatio(occupancyRatio);
692  }
693 }
694 
696 {
697  throw vpException(vpException::fatalError, "Cannot track with a grayscale image!");
698 }
699 
700 #ifdef VISP_HAVE_PCL
701 void vpMbDepthDenseTracker::track(const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &point_cloud)
702 {
703  segmentPointCloud(point_cloud);
704 
705  computeVVS();
706 
707  computeVisibility(point_cloud->width, point_cloud->height);
708 }
709 #endif
710 
711 void vpMbDepthDenseTracker::track(const std::vector<vpColVector> &point_cloud, const unsigned int width,
712  const unsigned int height)
713 {
714  segmentPointCloud(point_cloud, width, height);
715 
716  computeVVS();
717 
718  computeVisibility(width, height);
719 }
720 
721 void vpMbDepthDenseTracker::initCircle(const vpPoint & /*p1*/, const vpPoint & /*p2*/, const vpPoint & /*p3*/,
722  const double /*radius*/, const int /*idFace*/, const std::string & /*name*/)
723 {
724  throw vpException(vpException::fatalError, "vpMbDepthDenseTracker::initCircle() should not be called!");
725 }
726 
727 void vpMbDepthDenseTracker::initCylinder(const vpPoint & /*p1*/, const vpPoint & /*p2*/, const double /*radius*/,
728  const int /*idFace*/, const std::string & /*name*/)
729 {
730  throw vpException(vpException::fatalError, "vpMbDepthDenseTracker::initCylinder() should not be called!");
731 }
732 
733 void vpMbDepthDenseTracker::initFaceFromCorners(vpMbtPolygon &polygon) { addFace(polygon, false); }
734 
735 void vpMbDepthDenseTracker::initFaceFromLines(vpMbtPolygon &polygon) { addFace(polygon, true); }
vpMbHiddenFaces::setOgreShowConfigDialog
void setOgreShowConfigDialog(const bool showConfigDialog)
Definition: vpMbHiddenFaces.h:253
vpDisplayX
Use the X11 console to display images on unix-like OS. Thus to enable this class X11 should be instal...
Definition: vpDisplayX.h:150
vpMbtXmlGenericParser::setCameraParameters
void setCameraParameters(const vpCameraParameters &_cam)
Definition: vpMbtXmlGenericParser.h:397
vpMbDepthDenseTracker::m_depthDenseHiddenFacesDisplay
vpMbHiddenFaces< vpMbtPolygon > m_depthDenseHiddenFacesDisplay
Set of faces describing the object used only for display with scan line.
Definition: vpMbDepthDenseTracker.h:147
vpMbtXmlGenericParser::setAngleAppear
void setAngleAppear(const double &aappear)
Definition: vpMbtXmlGenericParser.h:383
vpMbtXmlGenericParser::getCameraParameters
void getCameraParameters(vpCameraParameters &_cam) const
Definition: vpMbtXmlGenericParser.h:229
vpColVector::resize
void resize(const unsigned int i, const bool flagNullify=true)
Definition: vpColVector.h:243
vpXmlParser::parse
void parse(const std::string &filename)
Definition: vpXmlParser.cpp:420
vpMbTracker::m_computeInteraction
bool m_computeInteraction
Definition: vpMbTracker.h:190
vpMbtFaceDepthDense::m_useScanLine
bool m_useScanLine
Scan line visibility.
Definition: vpMbtFaceDepthDense.h:81
vpMbTracker::distNearClip
double distNearClip
Distance for near clipping.
Definition: vpMbTracker.h:154
vpMath::sqr
static double sqr(double x)
Definition: vpMath.h:107
vpMbDepthDenseTracker::m_L_depthDense
vpMatrix m_L_depthDense
Interaction matrix.
Definition: vpMbDepthDenseTracker.h:163
vpMbtFaceDepthDense::addLine
void addLine(vpPoint &p1, vpPoint &p2, vpMbHiddenFaces< vpMbtPolygon > *const faces, int polygon=-1, std::string name="")
Definition: vpMbtFaceDepthDense.cpp:79
vpMbTracker::computeVVSCheckLevenbergMarquardt
virtual void computeVVSCheckLevenbergMarquardt(const unsigned int iter, vpColVector &error, const vpColVector &m_error_prev, const vpHomogeneousMatrix &cMoPrev, double &mu, bool &reStartFromLastIncrement, vpColVector *const w=NULL, const vpColVector *const m_w_prev=NULL)
Definition: vpMbTracker.cpp:2524
vpMbHiddenFaces::setVisibleOgre
unsigned int setVisibleOgre(const vpImage< unsigned char > &I, const vpCameraParameters &cam, const vpHomogeneousMatrix &cMo, const double &angleAppears, const double &angleDisappears, bool &changed)
Definition: vpMbHiddenFaces.h:768
vpMbHiddenFaces::reset
void reset()
Definition: vpMbHiddenFaces.h:397
vpMbtXmlGenericParser::setAngleDisappear
void setAngleDisappear(const double &adisappear)
Definition: vpMbtXmlGenericParser.h:390
vpMbHiddenFaces::computeClippedPolygons
void computeClippedPolygons(const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam)
Definition: vpMbHiddenFaces.h:440
vpMbTracker::useOgre
bool useOgre
Use Ogre3d for visibility tests.
Definition: vpMbTracker.h:160
vpMbTracker::loadModel
virtual void loadModel(const std::string &modelFile, const bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbTracker.cpp:1147
vpMatrix::insert
void insert(const vpMatrix &A, const unsigned int r, const unsigned int c)
Definition: vpMatrix.cpp:4569
vpImageConvert::convert
static void convert(const vpImage< unsigned char > &src, vpImage< vpRGBa > &dest)
Definition: vpImageConvert.cpp:78
vpMbtFaceDepthDense::m_distNearClip
double m_distNearClip
Distance for near clipping.
Definition: vpMbtFaceDepthDense.h:73
vpMath::rad
static double rad(double deg)
Definition: vpMath.h:101
vpMbTracker::cMo
vpHomogeneousMatrix cMo
The current pose.
Definition: vpMbTracker.h:118
vpMbDepthDenseTracker::m_depthDenseListOfActiveFaces
std::vector< vpMbtFaceDepthDense * > m_depthDenseListOfActiveFaces
List of current active (visible and features extracted) faces.
Definition: vpMbDepthDenseTracker.h:151
vpMatrix::AtA
vpMatrix AtA() const
Definition: vpMatrix.cpp:523
vpCameraParameters
Generic class defining intrinsic camera parameters.
Definition: vpCameraParameters.h:232
vpMbtXmlGenericParser::getDepthDenseSamplingStepY
unsigned int getDepthDenseSamplingStepY() const
Definition: vpMbtXmlGenericParser.h:244
vpMbtFaceDepthDense::m_planeObject
vpPlane m_planeObject
Plane equation described in the object frame.
Definition: vpMbtFaceDepthDense.h:77
vpMbtXmlGenericParser::getAngleDisappear
double getAngleDisappear() const
Definition: vpMbtXmlGenericParser.h:227
vpMbDepthDenseTracker::display
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)
Definition: vpMbDepthDenseTracker.cpp:289
vpMbTracker::GAUSS_NEWTON_OPT
Definition: vpMbTracker.h:112
vpMbDepthDenseTracker::setDepthDenseFilteringMethod
virtual void setDepthDenseFilteringMethod(const int method)
Definition: vpMbDepthDenseTracker.cpp:665
vpMbtFaceDepthDense::m_cam
vpCameraParameters m_cam
Camera intrinsic parameters.
Definition: vpMbtFaceDepthDense.h:67
vpMbHiddenFaces::isOgreInitialised
bool isOgreInitialised()
Definition: vpMbHiddenFaces.h:176
vpMbDepthDenseTracker::setDepthDenseFilteringMinDistance
virtual void setDepthDenseFilteringMinDistance(const double minDistance)
Definition: vpMbDepthDenseTracker.cpp:673
vpMath::deg
static double deg(double rad)
Definition: vpMath.h:94
vpMbDepthDenseTracker::computeVVSWeights
virtual void computeVVSWeights()
Definition: vpMbDepthDenseTracker.cpp:284
vpMbtFaceDepthDense::setTracked
void setTracked(const bool tracked)
Definition: vpMbtFaceDepthDense.h:156
vpHomogeneousMatrix::eye
void eye()
Definition: vpHomogeneousMatrix.cpp:663
vpMbDepthDenseTracker::~vpMbDepthDenseTracker
virtual ~vpMbDepthDenseTracker()
Definition: vpMbDepthDenseTracker.cpp:74
vpMbtFaceDepthDense::computeInteractionMatrixAndResidu
void computeInteractionMatrixAndResidu(const vpHomogeneousMatrix &cMo, vpMatrix &L, vpColVector &error)
Definition: vpMbtFaceDepthDense.cpp:425
vpException::fatalError
Fatal error.
Definition: vpException.h:95
vpMbDepthDenseTracker::m_w_depthDense
vpColVector m_w_depthDense
Robust weights.
Definition: vpMbDepthDenseTracker.h:167
vpMbDepthDenseTracker::m_depthDenseI_dummyVisibility
vpImage< unsigned char > m_depthDenseI_dummyVisibility
Dummy image used to compute the visibility.
Definition: vpMbDepthDenseTracker.h:149
vpMbTracker::computeCovariance
bool computeCovariance
Flag used to specify if the covariance matrix has to be computed or not.
Definition: vpMbTracker.h:133
vpException::ioError
I/O error.
Definition: vpException.h:90
vpMbTracker::modelInitialised
bool modelInitialised
Definition: vpMbTracker.h:128
vpMbTracker::faces
vpMbHiddenFaces< vpMbtPolygon > faces
Set of faces describing the object.
Definition: vpMbTracker.h:148
vpMbDepthDenseTracker::segmentPointCloud
void segmentPointCloud(const pcl::PointCloud< pcl::PointXYZ >::ConstPtr &point_cloud)
Definition: vpMbDepthDenseTracker.cpp:532
vpDisplayGDI
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:128
vpPolygon3D::FOV_CLIPPING
Definition: vpPolygon3D.h:69
vpMbDepthDenseTracker::m_weightedError_depthDense
vpColVector m_weightedError_depthDense
Weighted error.
Definition: vpMbDepthDenseTracker.h:169
vpMbDepthDenseTracker::init
virtual void init(const vpImage< unsigned char > &I)
Definition: vpMbDepthDenseTracker.cpp:345
vpMbDepthDenseTracker::setUseDepthDenseTracking
void setUseDepthDenseTracking(const std::string &name, const bool &useDepthDenseTracking)
Definition: vpMbDepthDenseTracker.cpp:518
vpMbtPolygon::getName
std::string getName() const
Definition: vpMbtPolygon.h:107
vpMbDepthDenseTracker::computeVVSInteractionMatrixAndResidu
virtual void computeVVSInteractionMatrixAndResidu()
Definition: vpMbDepthDenseTracker.cpp:265
vpMbtFaceDepthDense::m_hiddenFace
vpMbHiddenFaces< vpMbtPolygon > * m_hiddenFace
Pointer to the list of faces.
Definition: vpMbtFaceDepthDense.h:75
vpMbtXmlGenericParser::getFovClipping
bool getFovClipping() const
Definition: vpMbtXmlGenericParser.h:293
vpMbDepthDenseTracker::addFace
void addFace(vpMbtPolygon &polygon, const bool alreadyClose)
Definition: vpMbDepthDenseTracker.cpp:85
vpMbDepthDenseTracker::testTracking
virtual void testTracking()
Definition: vpMbDepthDenseTracker.cpp:529
vpPolygon3D::p
vpPoint * p
corners in the object frame
Definition: vpPolygon3D.h:80
vpMbDepthDenseTracker::track
virtual void track(const vpImage< unsigned char > &)
Definition: vpMbDepthDenseTracker.cpp:694
vpMbDepthDenseTracker::resetTracker
virtual void resetTracker()
Definition: vpMbDepthDenseTracker.cpp:447
vpMbDepthDenseTracker::computeVVS
void computeVVS()
Definition: vpMbDepthDenseTracker.cpp:153
vpMbtFaceDepthDense::display
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)
Definition: vpMbtFaceDepthDense.cpp:684
vpMbDepthDenseTracker::initCylinder
virtual void initCylinder(const vpPoint &p1, const vpPoint &p2, const double radius, const int idFace=0, const std::string &name="")
Definition: vpMbDepthDenseTracker.cpp:726
vpMbTracker::cam
vpCameraParameters cam
The camera parameters.
Definition: vpMbTracker.h:116
vpMbDepthDenseTracker::computeVVSInit
virtual void computeVVSInit()
Definition: vpMbDepthDenseTracker.cpp:247
vpMbDepthDenseTracker::initFaceFromCorners
virtual void initFaceFromCorners(vpMbtPolygon &polygon)
Definition: vpMbDepthDenseTracker.cpp:732
vpMbtFaceDepthDense::m_distFarClip
double m_distFarClip
Distance for near clipping.
Definition: vpMbtFaceDepthDense.h:71
vpMbTracker::m_lambda
double m_lambda
Gain of the virtual visual servoing stage.
Definition: vpMbTracker.h:192
vpColVector
Implementation of column vector and the associated operations.
Definition: vpColVector.h:71
vpMbTracker::useScanLine
bool useScanLine
Use Scanline for visibility tests.
Definition: vpMbTracker.h:163
vpMbtXmlGenericParser
Parse an Xml file to extract configuration parameters of a mbtConfig object.
Definition: vpMbtXmlGenericParser.h:63
vpMbDepthDenseTracker::computeVisibility
void computeVisibility(const unsigned int width, const unsigned int height)
Definition: vpMbDepthDenseTracker.cpp:128
vpAROgre::setWindowName
void setWindowName(const Ogre::String &n)
Definition: vpAROgre.h:268
vpMbTracker::initFromPose
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
Definition: vpMbTracker.cpp:841
vpMbtXmlGenericParser::getNearClippingDistance
double getNearClippingDistance() const
Definition: vpMbtXmlGenericParser.h:353
vpMatrix
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:103
vpMbDepthDenseTracker::m_depthDenseSamplingStepY
unsigned int m_depthDenseSamplingStepY
Sampling step in y-direction.
Definition: vpMbDepthDenseTracker.h:159
vpMbtPolygon
Implementation of a polygon of the model used by the model-based tracker.
Definition: vpMbtPolygon.h:65
vpMbDepthDenseTracker::m_depthDenseFaces
std::vector< vpMbtFaceDepthDense * > m_depthDenseFaces
List of faces.
Definition: vpMbDepthDenseTracker.h:155
vpColVector::insert
void insert(unsigned int i, const vpColVector &v)
Definition: vpColVector.cpp:1275
vpMbtFaceDepthDense
Definition: vpMbtFaceDepthDense.h:52
vpMbDepthDenseTracker::m_robust_depthDense
vpMbtTukeyEstimator< double > m_robust_depthDense
Tukey M-Estimator.
Definition: vpMbDepthDenseTracker.h:165
vpMbtFaceDepthDense::m_polygon
vpMbtPolygon * m_polygon
Polygon defining the face.
Definition: vpMbtFaceDepthDense.h:79
vpMbTracker::m_initialMu
double m_initialMu
Initial Mu for Levenberg Marquardt optimization loop.
Definition: vpMbTracker.h:198
vpMbtPolygon::getIndex
int getIndex() const
Definition: vpMbtPolygon.h:100
vpDisplay::display
static void display(const vpImage< unsigned char > &I)
Definition: vpDisplay_uchar.cpp:676
vpMbDepthDenseTracker::setDepthDenseFilteringOccupancyRatio
virtual void setDepthDenseFilteringOccupancyRatio(const double occupancyRatio)
Definition: vpMbDepthDenseTracker.cpp:681
vpMbTracker::distFarClip
double distFarClip
Distance for near clipping.
Definition: vpMbTracker.h:156
vpMbTracker::m_optimizationMethod
vpMbtOptimizationMethod m_optimizationMethod
Optimization method used.
Definition: vpMbTracker.h:145
vpMbTracker::displayFeatures
bool displayFeatures
If true, the features are displayed.
Definition: vpMbTracker.h:143
vpMbHiddenFaces::setBackgroundSizeOgre
void setBackgroundSizeOgre(const unsigned int &h, const unsigned int &w)
Definition: vpMbHiddenFaces.h:210
vpMbTracker::oJo
vpMatrix oJo
The Degrees of Freedom to estimate.
Definition: vpMbTracker.h:120
vpException::what
const char * what() const
Definition: vpException.cpp:101
vpImage::getHeight
unsigned int getHeight() const
Definition: vpImage.h:177
vpMbtXmlGenericParser::getAngleAppear
double getAngleAppear() const
Definition: vpMbtXmlGenericParser.h:222
vpMbDepthDenseTracker::loadConfigFile
virtual void loadConfigFile(const std::string &configFile)
Definition: vpMbDepthDenseTracker.cpp:378
vpMbtXmlGenericParser::setDepthDenseSamplingStepY
void setDepthDenseSamplingStepY(const unsigned int stepY)
Definition: vpMbtXmlGenericParser.h:411
vpVelocityTwistMatrix
Definition: vpVelocityTwistMatrix.h:113
vpMbDepthDenseTracker::initFaceFromLines
virtual void initFaceFromLines(vpMbtPolygon &polygon)
Definition: vpMbDepthDenseTracker.cpp:734
vpMbTracker::angleAppears
double angleAppears
Angle used to detect a face appearance.
Definition: vpMbTracker.h:150
vpMbtXmlGenericParser::DEPTH_DENSE_PARSER
Definition: vpMbtXmlGenericParser.h:72
vpMbtFaceDepthDense::getNbFeatures
unsigned int getNbFeatures() const
Definition: vpMbtFaceDepthDense.h:125
vpPolygon3D::nbpt
unsigned int nbpt
Number of points used to define the polygon.
Definition: vpPolygon3D.h:75
vpMbDepthDenseTracker::setScanLineVisibilityTest
virtual void setScanLineVisibilityTest(const bool &v)
Definition: vpMbDepthDenseTracker.cpp:508
vpMbtFaceDepthDense::isTracked
bool isTracked() const
Definition: vpMbtFaceDepthDense.h:127
vpMbDepthDenseTracker::vpMbDepthDenseTracker
vpMbDepthDenseTracker()
Definition: vpMbDepthDenseTracker.cpp:54
vpMbDepthDenseTracker::initCircle
virtual void initCircle(const vpPoint &p1, const vpPoint &p2, const vpPoint &p3, const double radius, const int idFace=0, const std::string &name="")
Definition: vpMbDepthDenseTracker.cpp:720
vpMbTracker::computeVVSPoseEstimation
virtual void computeVVSPoseEstimation(const bool isoJoIdentity_, const unsigned int iter, vpMatrix &L, vpMatrix &LTL, vpColVector &R, const vpColVector &error, vpColVector &error_prev, vpColVector &LTR, double &mu, vpColVector &v, const vpColVector *const w=NULL, vpColVector *const m_w_prev=NULL)
Definition: vpMbTracker.cpp:2546
vpExponentialMap::direct
static vpHomogeneousMatrix direct(const vpColVector &v)
Definition: vpExponentialMap.cpp:58
vpMbtFaceDepthDense::m_clippingFlag
unsigned int m_clippingFlag
Flags specifying which clipping to used.
Definition: vpMbtFaceDepthDense.h:69
vpVelocityTwistMatrix::buildFrom
vpVelocityTwistMatrix buildFrom(const vpTranslationVector &t, const vpRotationMatrix &R)
Definition: vpVelocityTwistMatrix.cpp:364
vpPolygon3D::getNbPoint
unsigned int getNbPoint() const
Definition: vpPolygon3D.h:131
vpMbtXmlGenericParser::getFarClippingDistance
double getFarClippingDistance() const
Definition: vpMbtXmlGenericParser.h:288
vpMbtXmlGenericParser::hasFarClippingDistance
bool hasFarClippingDistance() const
Definition: vpMbtXmlGenericParser.h:367
vpMbtXmlGenericParser::getDepthDenseSamplingStepX
unsigned int getDepthDenseSamplingStepX() const
Definition: vpMbtXmlGenericParser.h:239
vpMbTracker::m_mask
const vpImage< bool > * m_mask
Mask used to disable tracking on a part of image.
Definition: vpMbTracker.h:226
vpMbHiddenFaces::initOgre
void initOgre(const vpCameraParameters &cam=vpCameraParameters())
Definition: vpMbHiddenFaces.h:710
vpMbtXmlGenericParser::hasNearClippingDistance
bool hasNearClippingDistance() const
Definition: vpMbtXmlGenericParser.h:374
vpMbDepthDenseTracker::setPose
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
Definition: vpMbDepthDenseTracker.cpp:492
vpMbTracker::setOgreVisibilityTest
virtual void setOgreVisibilityTest(const bool &v)
Definition: vpMbTracker.cpp:2313
vpMbtFaceDepthDense::isVisible
bool isVisible() const
Definition: vpMbtFaceDepthDense.h:129
vpPlane
This class defines the container for a plane geometrical structure.
Definition: vpPlane.h:57
vpMbTracker::setClipping
virtual void setClipping(const unsigned int &flags)
Definition: vpMbTracker.cpp:2437
vpMbTracker::m_maxIter
unsigned int m_maxIter
Maximum number of iterations of the virtual visual servoing stage.
Definition: vpMbTracker.h:194
vpMbTracker::ogreShowConfigDialog
bool ogreShowConfigDialog
Definition: vpMbTracker.h:161
vpMbTracker::clippingFlag
unsigned int clippingFlag
Flags specifying which clipping to used.
Definition: vpMbTracker.h:158
vpMbDepthDenseTracker::setCameraParameters
virtual void setCameraParameters(const vpCameraParameters &camera)
Definition: vpMbDepthDenseTracker.cpp:647
vpPlane::object_frame
Definition: vpPlane.h:69
vpMbDepthDenseTracker::m_depthDenseSamplingStepX
unsigned int m_depthDenseSamplingStepX
Sampling step in x-direction.
Definition: vpMbDepthDenseTracker.h:157
vpMbDepthDenseTracker::setOgreVisibilityTest
virtual void setOgreVisibilityTest(const bool &v)
Definition: vpMbDepthDenseTracker.cpp:484
vpDisplay::flush
static void flush(const vpImage< unsigned char > &I)
Definition: vpDisplay_uchar.cpp:652
vpMbHiddenFaces::getOgreContext
vpAROgre * getOgreContext()
Definition: vpMbHiddenFaces.h:154
vpMbTracker::setNearClippingDistance
virtual void setNearClippingDistance(const double &dist)
Definition: vpMbTracker.cpp:2410
vpMbTracker::setFarClippingDistance
virtual void setFarClippingDistance(const double &dist)
Definition: vpMbTracker.cpp:2331
vpMbTracker::computeCovarianceMatrixVVS
virtual void computeCovarianceMatrixVVS(const bool isoJoIdentity_, const vpColVector &w_true, const vpHomogeneousMatrix &cMoPrev, const vpMatrix &L_true, const vpMatrix &LVJ_true, const vpColVector &error)
Definition: vpMbTracker.cpp:2444
vpImage< unsigned char >
vpHomogeneousMatrix::inverse
vpHomogeneousMatrix inverse() const
Definition: vpHomogeneousMatrix.cpp:642
vpMbDepthDenseTracker::setDepthDenseSamplingStep
void setDepthDenseSamplingStep(const unsigned int stepX, const unsigned int stepY)
Definition: vpMbDepthDenseTracker.h:115
vpMbDepthDenseTracker::setDepthDenseFilteringMaxDistance
virtual void setDepthDenseFilteringMaxDistance(const double maxDistance)
Definition: vpMbDepthDenseTracker.cpp:657
vpMbDepthDenseTracker::m_error_depthDense
vpColVector m_error_depthDense
(s - s*)
Definition: vpMbDepthDenseTracker.h:161
vpPoint
Class that defines what is a point.
Definition: vpPoint.h:57
vpArray2D::resize
void resize(const unsigned int nrows, const unsigned int ncols, const bool flagNullify=true, const bool recopy_=true)
Definition: vpArray2D.h:170
vpColor
Class to define colors available for display functionnalities.
Definition: vpColor.h:119
vpDisplay::displayLine
static void displayLine(const vpImage< unsigned char > &I, const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color, unsigned int thickness=1)
Definition: vpDisplay_uchar.cpp:391
vpMbDepthDenseTracker::m_denseDepthNbFeatures
unsigned int m_denseDepthNbFeatures
Nb features.
Definition: vpMbDepthDenseTracker.h:153
vpMbHiddenFaces::setVisible
unsigned int setVisible(const vpImage< unsigned char > &I, const vpCameraParameters &cam, const vpHomogeneousMatrix &cMo, const double &angle, bool &changed)
Definition: vpMbHiddenFaces.h:659
vpHomogeneousMatrix
Implementation of an homogeneous matrix and operations on such kind of matrices.
Definition: vpHomogeneousMatrix.h:91
vpMbTracker::m_stopCriteriaEpsilon
double m_stopCriteriaEpsilon
Epsilon threshold to stop the VVS optimization loop.
Definition: vpMbTracker.h:196
vpMbtXmlGenericParser::setDepthDenseSamplingStepX
void setDepthDenseSamplingStepX(const unsigned int stepX)
Definition: vpMbtXmlGenericParser.h:404
vpMbTracker::setScanLineVisibilityTest
virtual void setScanLineVisibilityTest(const bool &v)
Definition: vpMbTracker.h:586
vpMbHiddenFaces::computeScanLineRender
void computeScanLineRender(const vpCameraParameters &cam, const unsigned int &w, const unsigned int &h)
Definition: vpMbHiddenFaces.h:463
vpImage::resize
void resize(const unsigned int h, const unsigned int w)
resize the image : Image initialization
Definition: vpImage.h:865
vpMbtFaceDepthDense::computeDesiredFeatures
bool computeDesiredFeatures(const vpHomogeneousMatrix &cMo, const pcl::PointCloud< pcl::PointXYZ >::ConstPtr &point_cloud, const unsigned int stepX, const unsigned int stepY, const vpImage< bool > *mask=NULL)
Definition: vpMbtFaceDepthDense.cpp:140
vpException
error that can be emited by ViSP classes.
Definition: vpException.h:70
vpCameraParameters::computeFov
void computeFov(const unsigned int &w, const unsigned int &h)
Definition: vpCameraParameters.cpp:432
vpPolygon3D::NO_CLIPPING
Definition: vpPolygon3D.h:62
vpColor::red
static const vpColor red
Definition: vpColor.h:179
vpMbtFaceDepthDense::displayFeature
void displayFeature(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const double scale=0.05, const unsigned int thickness=1)
Definition: vpMbtFaceDepthDense.cpp:714
vpMbTracker::angleDisappears
double angleDisappears
Angle used to detect a face disappearance.
Definition: vpMbTracker.h:152
vpMbDepthDenseTracker::reInitModel
void reInitModel(const vpImage< unsigned char > &I, const std::string &cad_name, const vpHomogeneousMatrix &cMo_, const bool verbose=false)
Definition: vpMbDepthDenseTracker.cpp:420
vpMatrix::eye
void eye()
Definition: vpMatrix.cpp:359
vpImage::getWidth
unsigned int getWidth() const
Definition: vpImage.h:238
vpMbtFaceDepthDense::computeVisibility
void computeVisibility()
Definition: vpMbtFaceDepthDense.cpp:390
vpArray2D::getRows
unsigned int getRows() const
Definition: vpArray2D.h:155