Visual Servoing Platform  version 3.3.0
vpMbEdgeKltMultiTracker.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 edge klt tracker with multiple cameras.
33  *
34  * Authors:
35  * Souriya Trinh
36  *
37  *****************************************************************************/
38 
44 #include <visp3/core/vpConfig.h>
45 
46 #if defined(VISP_BUILD_DEPRECATED_FUNCTIONS)
47 
48 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION >= 0x020100)
49 
50 #include <visp3/core/vpTrackingException.h>
51 #include <visp3/core/vpVelocityTwistMatrix.h>
52 #include <visp3/mbt/vpMbEdgeKltMultiTracker.h>
53 
58  : vpMbEdgeMultiTracker(), vpMbKltMultiTracker(), m_factorKLT(0.65), m_factorMBT(0.35), m_thresholdKLT(2.),
59  m_thresholdMBT(2.), m_mapOfCameraTransformationMatrix(), m_referenceCameraName("Camera"), m_nbrow(0),
60  m_L_hybridMulti(), m_error_hybridMulti(), m_w_hybridMulti(), m_weightedError_hybridMulti()
61 {
62  // Add default camera transformation matrix
63  m_mapOfCameraTransformationMatrix["Camera"] = vpHomogeneousMatrix();
64 
65  m_lambda = 0.8;
66  m_maxIter = 200;
67 }
68 
75  : vpMbEdgeMultiTracker(nbCameras), vpMbKltMultiTracker(nbCameras), m_factorKLT(0.65), m_factorMBT(0.35),
76  m_thresholdKLT(2.), m_thresholdMBT(2.), m_mapOfCameraTransformationMatrix(), m_referenceCameraName("Camera"),
77  m_nbrow(0), m_L_hybridMulti(), m_error_hybridMulti(), m_w_hybridMulti(), m_weightedError_hybridMulti()
78 {
79 
80  if (nbCameras == 0) {
81  throw vpException(vpTrackingException::fatalError, "Cannot construct a vpMbkltMultiTracker with no camera !");
82  } else if (nbCameras == 1) {
83  // Add default camera transformation matrix
84  m_mapOfCameraTransformationMatrix["Camera"] = vpHomogeneousMatrix();
85  } else if (nbCameras == 2) {
86  // Add default camera transformation matrix
87  m_mapOfCameraTransformationMatrix["Camera1"] = vpHomogeneousMatrix();
88  m_mapOfCameraTransformationMatrix["Camera2"] = vpHomogeneousMatrix();
89 
90  // Set by default the reference camera
91  m_referenceCameraName = "Camera1";
92  } else {
93  for (unsigned int i = 1; i <= nbCameras; i++) {
94  std::stringstream ss;
95  ss << "Camera" << i;
96 
97  // Add default camera transformation matrix
98  m_mapOfCameraTransformationMatrix[ss.str()] = vpHomogeneousMatrix();
99  }
100 
101  // Set by default the reference camera to the first one
102  m_referenceCameraName = m_mapOfKltTrackers.begin()->first;
103  }
104 
105  m_lambda = 0.8;
106  m_maxIter = 200;
107 }
108 
114 vpMbEdgeKltMultiTracker::vpMbEdgeKltMultiTracker(const std::vector<std::string> &cameraNames)
115  : vpMbEdgeMultiTracker(cameraNames), vpMbKltMultiTracker(cameraNames), m_factorKLT(0.65), m_factorMBT(0.35),
116  m_thresholdKLT(2.), m_thresholdMBT(2.), m_mapOfCameraTransformationMatrix(), m_referenceCameraName(cameraNames.front()),
117  m_nbrow(0), m_L_hybridMulti(), m_error_hybridMulti(), m_w_hybridMulti(), m_weightedError_hybridMulti()
118 {
119  m_lambda = 0.8;
120  m_maxIter = 200;
121 }
122 
124 
125 void vpMbEdgeKltMultiTracker::computeVVS(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
126  unsigned int lvl)
127 {
128 
129  m_nbrow = initMbtTracking(mapOfImages, lvl);
130 
131  if (m_nbInfos < 4 && m_nbrow < 4) {
132  throw vpTrackingException(vpTrackingException::notEnoughPointError, "Error: not enough features");
133  } else if (m_nbrow < 4) {
134  m_nbrow = 0;
135  }
136 
137  double factorMBT = m_factorMBT;
138  double factorKLT = m_factorKLT;
139  if (m_nbrow < 4) {
140  factorKLT = 1.;
141  std::cerr << "There are less than 4 KLT features, set factorKLT = 1. !" << std::endl;
142  }
143 
144  if (m_nbInfos < 4) {
145  factorMBT = 1.;
146  std::cerr << "There are less than 4 moving edges, set factorMBT = 1. !" << std::endl;
147  m_nbInfos = 0;
148  }
149 
150  computeVVSInit();
151 
152  vpHomogeneousMatrix cMoPrev;
153  vpHomogeneousMatrix ctTc0_Prev;
154  // Error vector for MBT + KLT for the previous iteration
155  vpColVector m_error_prev;
156  // Weighting vector for MBT + KLT for the previous iteration
157  vpColVector m_w_prev;
158  double mu = m_initialMu;
159 
160  // Create the map of VelocityTwistMatrices
161  std::map<std::string, vpVelocityTwistMatrix> mapOfVelocityTwist;
162  for (std::map<std::string, vpHomogeneousMatrix>::const_iterator it = m_mapOfCameraTransformationMatrix.begin();
163  it != m_mapOfCameraTransformationMatrix.end(); ++it) {
165  cVo.buildFrom(it->second);
166  mapOfVelocityTwist[it->first] = cVo;
167  }
168 
169  // Variables used in the minimization process
170  double residu = 0;
171  double residu_1 = -1;
172  unsigned int iter = 0;
173 
174  vpMatrix L_true;
175  vpMatrix LVJ_true;
176 
177  vpColVector v;
178 
179  vpMatrix LTL;
180  vpColVector LTR;
181 
182  while (((int)((residu - residu_1) * 1e8) != 0) && (iter < m_maxIter)) {
183  computeVVSInteractionMatrixAndResidu(mapOfImages, mapOfVelocityTwist);
184 
185  bool reStartFromLastIncrement = false;
186  computeVVSCheckLevenbergMarquardt(iter, m_error_hybridMulti, m_error_prev, cMoPrev, mu, reStartFromLastIncrement,
187  &m_w_prev);
188  if (reStartFromLastIncrement) {
189  ctTc0 = ctTc0_Prev;
190  }
191 
192  if (!reStartFromLastIncrement) {
194 
195  // Set weight for m_w with the good weighting between MBT and KLT
196  for (unsigned int cpt = 0; cpt < m_nbrow + 2 * m_nbInfos; cpt++) {
197  if (cpt < m_nbrow) {
198  m_w_hybridMulti[cpt] = (m_w_hybridMulti[cpt] * m_factor[cpt]) * factorMBT;
199  } else {
200  m_w_hybridMulti[cpt] *= factorKLT;
201  }
202  }
203 
204  if (computeCovariance) {
205  L_true = m_L_hybridMulti;
206  if (!isoJoIdentity) {
208  cVo.buildFrom(m_cMo);
209  LVJ_true = (m_L_hybridMulti * cVo * oJo);
210  }
211  }
212 
213  residu_1 = residu;
214  residu = 0;
215  double num = 0;
216  double den = 0;
217 
218  for (unsigned int i = 0; i < m_weightedError_hybridMulti.getRows(); i++) {
220  den += m_w_hybridMulti[i];
221 
223  if (m_computeInteraction) {
224  for (unsigned int j = 0; j < 6; j++) {
225  m_L_hybridMulti[i][j] *= m_w_hybridMulti[i];
226  }
227  }
228  }
229 
230  residu = sqrt(num / den);
231 
233  m_error_hybridMulti, m_error_prev, LTR, mu, v, &m_w_hybridMulti, &m_w_prev);
234 
235  cMoPrev = m_cMo;
236  ctTc0_Prev = ctTc0;
238  m_cMo = ctTc0 * c0Mo;
239  }
240 
241  iter++;
242  }
243 
245 }
246 
248 {
249  unsigned int totalNbRows = 2 * m_nbInfos + m_nbrow;
250 
251  m_L_hybridMulti.resize(totalNbRows, 6, false, false);
252  m_error_hybridMulti.resize(totalNbRows, false);
253 
254  m_weightedError_hybridMulti.resize(totalNbRows, false);
255  m_w_hybridMulti.resize(totalNbRows, false);
256  m_w_hybridMulti = 1;
257 
258  for (std::map<std::string, vpMbKltTracker *>::const_iterator it = m_mapOfKltTrackers.begin();
259  it != m_mapOfKltTrackers.end(); ++it) {
260  vpMbKltTracker *klt = it->second;
261  klt->computeVVSInit();
262  }
263 }
264 
266 {
267  throw vpException(vpException::fatalError, "vpMbEdgeKltMultiTracker::"
268  "computeVVSInteractionMatrixAndR"
269  "esidu() should not be called!");
270 }
271 
273  std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
274  std::map<std::string, vpVelocityTwistMatrix> &mapOfVelocityTwist)
275 {
276  unsigned int startIdx = 0;
277 
278  if (m_nbrow >= 4) {
279  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
280  it != m_mapOfEdgeTrackers.end(); ++it) {
281  vpMbEdgeTracker *edge = it->second;
282 
283  // Set the corresponding cMo for the current camera
284  it->second->m_cMo = m_mapOfCameraTransformationMatrix[it->first] * m_cMo;
285 
286  edge->computeVVSInteractionMatrixAndResidu(*mapOfImages[it->first]);
287 
288  // Stack interaction matrix for MBT
289  m_L_hybridMulti.insert(edge->m_L_edge * mapOfVelocityTwist[it->first], startIdx, 0);
290  // Stack residual for MBT
291  m_error_hybridMulti.insert(startIdx, edge->m_error_edge);
292 
293  startIdx += edge->m_error_edge.getRows();
294  }
295  }
296 
297  for (std::map<std::string, vpMbKltTracker *>::const_iterator it = m_mapOfKltTrackers.begin();
298  it != m_mapOfKltTrackers.end(); ++it) {
299  vpMbKltTracker *klt = it->second;
300 
301  if (klt->m_nbInfos > 0) {
302 
303  // Use the ctTc0 variable instead of the formula in the monocular case
304  // to ensure that we have the same result than vpMbKltTracker
305  // as some slight differences can occur due to numerical imprecision
306  if (m_mapOfKltTrackers.size() == 1) {
307  klt->ctTc0 = ctTc0;
309  } else {
310  vpHomogeneousMatrix c_curr_tTc_curr0 = m_mapOfCameraTransformationMatrix[it->first] * m_cMo * klt->c0Mo.inverse();
311  klt->ctTc0 = c_curr_tTc_curr0;
313  }
314 
315  // Stack residual and interaction matrix
316  m_error_hybridMulti.insert(startIdx, klt->m_error_klt);
317  m_L_hybridMulti.insert(klt->m_L_klt * mapOfVelocityTwist[it->first], startIdx, 0);
318 
319  startIdx += 2 * klt->m_nbInfos;
320  }
321  }
322 }
323 
325 {
326  unsigned int startIdx = 0;
327 
328  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
329  it != m_mapOfEdgeTrackers.end(); ++it) {
330  vpMbEdgeTracker *edge = it->second;
331 
332  // Compute weights
333  edge->computeVVSWeights();
334 
335  m_w_hybridMulti.insert(startIdx, edge->m_w_edge);
336  startIdx += edge->m_w_edge.getRows();
337  }
338 
339  for (std::map<std::string, vpMbKltTracker *>::const_iterator it = m_mapOfKltTrackers.begin();
340  it != m_mapOfKltTrackers.end(); ++it) {
341  vpMbKltTracker *klt = it->second;
342 
343  // Compute weights
344  klt->computeVVSWeights(klt->m_robust_klt, klt->m_error_klt, klt->m_w_klt);
345 
346  m_w_hybridMulti.insert(startIdx, klt->m_w_klt);
347  startIdx += klt->m_w_klt.getRows();
348  }
349 }
350 
363  const vpCameraParameters &cam, const vpColor &col, unsigned int thickness,
364  bool displayFullModel)
365 {
366  vpMbEdgeMultiTracker::display(I, cMo, cam, col, thickness, displayFullModel);
367 
368  // Display only features for KLT trackers
369  for (std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.begin();
370  it_klt != m_mapOfKltTrackers.end(); ++it_klt) {
371 
372  for (std::list<vpMbtDistanceKltPoints *>::const_iterator it_pts = it_klt->second->kltPolygons.begin();
373  it_pts != it_klt->second->kltPolygons.end(); ++it_pts) {
374  vpMbtDistanceKltPoints *kltpoly = *it_pts;
375  if (displayFeatures && kltpoly->hasEnoughPoints() && kltpoly->isTracked() && kltpoly->polygon->isVisible()) {
376  kltpoly->displayPrimitive(I);
377  }
378  }
379 
380  for (std::list<vpMbtDistanceKltCylinder *>::const_iterator it_cyl = it_klt->second->kltCylinders.begin();
381  it_cyl != it_klt->second->kltCylinders.end(); ++it_cyl) {
382  vpMbtDistanceKltCylinder *kltPolyCylinder = *it_cyl;
383  if (displayFeatures && kltPolyCylinder->isTracked() && kltPolyCylinder->hasEnoughPoints())
384  kltPolyCylinder->displayPrimitive(I);
385  }
386  }
387 }
388 
401  const vpCameraParameters &cam, const vpColor &color,
402  unsigned int thickness, bool displayFullModel)
403 {
404  vpMbEdgeMultiTracker::display(I, cMo, cam, color, thickness, displayFullModel);
405  // vpMbKltMultiTracker::display(I, cMo_, cam_, color, thickness,
406  // displayFullModel);
407 
408  // Display only features for KLT trackers
409  for (std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.begin();
410  it_klt != m_mapOfKltTrackers.end(); ++it_klt) {
411 
412  for (std::list<vpMbtDistanceKltPoints *>::const_iterator it_pts = it_klt->second->kltPolygons.begin();
413  it_pts != it_klt->second->kltPolygons.end(); ++it_pts) {
414  vpMbtDistanceKltPoints *kltpoly = *it_pts;
415  if (displayFeatures && kltpoly->hasEnoughPoints() && kltpoly->isTracked() && kltpoly->polygon->isVisible()) {
416  kltpoly->displayPrimitive(I);
417  }
418  }
419 
420  for (std::list<vpMbtDistanceKltCylinder *>::const_iterator it_cyl = it_klt->second->kltCylinders.begin();
421  it_cyl != it_klt->second->kltCylinders.end(); ++it_cyl) {
422  vpMbtDistanceKltCylinder *kltPolyCylinder = *it_cyl;
423  if (displayFeatures && kltPolyCylinder->isTracked() && kltPolyCylinder->hasEnoughPoints())
424  kltPolyCylinder->displayPrimitive(I);
425  }
426  }
427 }
428 
444  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo,
445  const vpCameraParameters &cam1, const vpCameraParameters &cam2,
446  const vpColor &color, unsigned int thickness, bool displayFullModel)
447 {
448  vpMbEdgeMultiTracker::display(I1, I2, c1Mo, c2Mo, cam1, cam2, color, thickness, displayFullModel);
449  // vpMbKltMultiTracker::display(I1, I2, c1Mo, c2Mo, cam1, cam2, color,
450  // thickness, displayFullModel);
451 
452  // Display only features for KLT trackers
453  bool first = true;
454  for (std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.begin();
455  it_klt != m_mapOfKltTrackers.end(); ++it_klt) {
456  for (std::list<vpMbtDistanceKltPoints *>::const_iterator it_pts = it_klt->second->kltPolygons.begin();
457  it_pts != it_klt->second->kltPolygons.end(); ++it_pts) {
458  vpMbtDistanceKltPoints *kltpoly = *it_pts;
459  if (displayFeatures && kltpoly->hasEnoughPoints() && kltpoly->isTracked() && kltpoly->polygon->isVisible()) {
460  if (first) {
461  kltpoly->displayPrimitive(I1);
462  } else {
463  kltpoly->displayPrimitive(I2);
464  }
465  }
466  }
467 
468  for (std::list<vpMbtDistanceKltCylinder *>::const_iterator it_cyl = it_klt->second->kltCylinders.begin();
469  it_cyl != it_klt->second->kltCylinders.end(); ++it_cyl) {
470  vpMbtDistanceKltCylinder *kltPolyCylinder = *it_cyl;
471  if (displayFeatures && kltPolyCylinder->isTracked() && kltPolyCylinder->hasEnoughPoints()) {
472  if (first) {
473  kltPolyCylinder->displayPrimitive(I1);
474  } else {
475  kltPolyCylinder->displayPrimitive(I2);
476  }
477  }
478  }
479 
480  first = false;
481  }
482 }
483 
499  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo,
500  const vpCameraParameters &cam1, const vpCameraParameters &cam2,
501  const vpColor &color, unsigned int thickness, bool displayFullModel)
502 {
503  vpMbEdgeMultiTracker::display(I1, I2, c1Mo, c2Mo, cam1, cam2, color, thickness, displayFullModel);
504  // vpMbKltMultiTracker::display(I1, I2, c1Mo, c2Mo, cam1, cam2, color,
505  // thickness, displayFullModel);
506 
507  // Display only features for KLT trackers (not the model)
508  bool first = true;
509  for (std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.begin();
510  it_klt != m_mapOfKltTrackers.end(); ++it_klt) {
511  for (std::list<vpMbtDistanceKltPoints *>::const_iterator it_pts = it_klt->second->kltPolygons.begin();
512  it_pts != it_klt->second->kltPolygons.end(); ++it_pts) {
513  vpMbtDistanceKltPoints *kltpoly = *it_pts;
514  if (displayFeatures && kltpoly->hasEnoughPoints() && kltpoly->isTracked() && kltpoly->polygon->isVisible()) {
515  if (first) {
516  kltpoly->displayPrimitive(I1);
517  } else {
518  kltpoly->displayPrimitive(I2);
519  }
520  }
521  }
522 
523  for (std::list<vpMbtDistanceKltCylinder *>::const_iterator it_cyl = it_klt->second->kltCylinders.begin();
524  it_cyl != it_klt->second->kltCylinders.end(); ++it_cyl) {
525  vpMbtDistanceKltCylinder *kltPolyCylinder = *it_cyl;
526  if (displayFeatures && kltPolyCylinder->isTracked() && kltPolyCylinder->hasEnoughPoints()) {
527  if (first) {
528  kltPolyCylinder->displayPrimitive(I1);
529  } else {
530  kltPolyCylinder->displayPrimitive(I2);
531  }
532  }
533  }
534 
535  first = false;
536  }
537 }
538 
550 void vpMbEdgeKltMultiTracker::display(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
551  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses,
552  const std::map<std::string, vpCameraParameters> &mapOfCameraParameters,
553  const vpColor &col, unsigned int thickness, bool displayFullModel)
554 {
555  vpMbEdgeMultiTracker::display(mapOfImages, mapOfCameraPoses, mapOfCameraParameters, col, thickness, displayFullModel);
556  // vpMbKltMultiTracker::display(mapOfImages, mapOfCameraPoses,
557  // mapOfCameraParameters, col, thickness, displayFullModel);
558 
559  // Display only features for KLT trackers (not the model)
560  for (std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.begin();
561  it_klt != m_mapOfKltTrackers.end(); ++it_klt) {
562 
563  std::map<std::string, const vpImage<unsigned char> *>::const_iterator it_img = mapOfImages.find(it_klt->first);
564  if (it_img != mapOfImages.end()) {
565  for (std::list<vpMbtDistanceKltPoints *>::const_iterator it_pts = it_klt->second->kltPolygons.begin();
566  it_pts != it_klt->second->kltPolygons.end(); ++it_pts) {
567  vpMbtDistanceKltPoints *kltpoly = *it_pts;
568  if (displayFeatures && kltpoly->hasEnoughPoints() && kltpoly->isTracked() && kltpoly->polygon->isVisible()) {
569  kltpoly->displayPrimitive(*(it_img->second));
570  }
571  }
572 
573  for (std::list<vpMbtDistanceKltCylinder *>::const_iterator it_cyl = it_klt->second->kltCylinders.begin();
574  it_cyl != it_klt->second->kltCylinders.end(); ++it_cyl) {
575  vpMbtDistanceKltCylinder *kltPolyCylinder = *it_cyl;
576  if (displayFeatures && kltPolyCylinder->isTracked() && kltPolyCylinder->hasEnoughPoints())
577  kltPolyCylinder->displayPrimitive(*(it_img->second));
578  }
579  }
580  }
581 }
582 
594 void vpMbEdgeKltMultiTracker::display(const std::map<std::string, const vpImage<vpRGBa> *> &mapOfImages,
595  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses,
596  const std::map<std::string, vpCameraParameters> &mapOfCameraParameters,
597  const vpColor &col, unsigned int thickness, bool displayFullModel)
598 {
599  vpMbEdgeMultiTracker::display(mapOfImages, mapOfCameraPoses, mapOfCameraParameters, col, thickness, displayFullModel);
600  // vpMbKltMultiTracker::display(mapOfImages, mapOfCameraPoses,
601  // mapOfCameraParameters, col, thickness, displayFullModel);
602 
603  // Display only features for KLT trackers (not the model)
604  for (std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.begin();
605  it_klt != m_mapOfKltTrackers.end(); ++it_klt) {
606 
607  std::map<std::string, const vpImage<vpRGBa> *>::const_iterator it_img = mapOfImages.find(it_klt->first);
608  if (it_img != mapOfImages.end()) {
609  for (std::list<vpMbtDistanceKltPoints *>::const_iterator it_pts = it_klt->second->kltPolygons.begin();
610  it_pts != it_klt->second->kltPolygons.end(); ++it_pts) {
611  vpMbtDistanceKltPoints *kltpoly = *it_pts;
612  if (displayFeatures && kltpoly->hasEnoughPoints() && kltpoly->isTracked() && kltpoly->polygon->isVisible()) {
613  kltpoly->displayPrimitive(*(it_img->second));
614  }
615  }
616 
617  for (std::list<vpMbtDistanceKltCylinder *>::const_iterator it_cyl = it_klt->second->kltCylinders.begin();
618  it_cyl != it_klt->second->kltCylinders.end(); ++it_cyl) {
619  vpMbtDistanceKltCylinder *kltPolyCylinder = *it_cyl;
620  if (displayFeatures && kltPolyCylinder->isTracked() && kltPolyCylinder->hasEnoughPoints())
621  kltPolyCylinder->displayPrimitive(*(it_img->second));
622  }
623  }
624  }
625 }
626 
632 std::vector<std::string> vpMbEdgeKltMultiTracker::getCameraNames() const
633 {
635 }
636 
643 
651 {
652  // We could use either the vpMbEdgeMultiTracker or vpMbKltMultiTracker class
654 }
655 
662 void vpMbEdgeKltMultiTracker::getCameraParameters(const std::string &cameraName, vpCameraParameters &camera) const
663 {
664  // We could use either the vpMbEdgeMultiTracker or vpMbKltMultiTracker class
665  vpMbEdgeMultiTracker::getCameraParameters(cameraName, camera);
666 }
667 
674  std::map<std::string, vpCameraParameters> &mapOfCameraParameters) const
675 {
676  // Clear the input map
677  mapOfCameraParameters.clear();
678 
679  // We could use either the vpMbEdgeMultiTracker or vpMbKltMultiTracker class
680  vpMbEdgeMultiTracker::getCameraParameters(mapOfCameraParameters);
681 }
682 
690 unsigned int vpMbEdgeKltMultiTracker::getClipping(const std::string &cameraName) const
691 {
692  std::map<std::string, vpMbKltTracker *>::const_iterator it = m_mapOfKltTrackers.find(cameraName);
693  if (it != m_mapOfKltTrackers.end()) {
694  // Return the clipping flags for m_mapOfKltTrackers as it should be the
695  // same for the same camera in m_mapOfEdgeTrackers
696  return it->second->getClipping();
697  } else {
698  std::cerr << "Cannot find camera: " << cameraName << std::endl;
699  }
700 
701  return vpMbTracker::getClipping();
702 }
703 
705 {
706  std::cerr << "Return the wrong faces reference !" << std::endl;
707  std::cerr << "Use vpMbEdgeKltMultiTracker::getEdgeFaces or "
708  "vpMbEdgeKltMultiTracker::getKltFaces instead !"
709  << std::endl;
710 
711  return faces;
712 }
713 
721 {
722  return vpMbEdgeMultiTracker::getFaces(cameraName);
723 }
724 
730 std::map<std::string, vpMbHiddenFaces<vpMbtPolygon> > vpMbEdgeKltMultiTracker::getEdgeFaces() const
731 {
733 }
734 
742 {
743  return vpMbKltMultiTracker::getFaces(cameraName);
744 }
745 
751 std::map<std::string, vpMbHiddenFaces<vpMbtPolygon> > vpMbEdgeKltMultiTracker::getKltFaces() const
752 {
754 }
755 
756 unsigned int vpMbEdgeKltMultiTracker::getNbPolygon() const
757 {
758  std::cerr << "Use vpMbEdgeKltMultiTracker::getEdgeMultiNbPolygon or "
759  "vpMbEdgeKltMultiTracker::getKltMultiNbPolygon instead !"
760  << std::endl;
761  return 0;
762 }
763 
770 std::map<std::string, unsigned int> vpMbEdgeKltMultiTracker::getEdgeMultiNbPolygon() const
771 {
773 }
774 
781 std::map<std::string, unsigned int> vpMbEdgeKltMultiTracker::getKltMultiNbPolygon() const
782 {
784 }
785 
793 {
794  // We could use either the vpMbEdgeMultiTracker or vpMbKltMultiTracker class
795  vpMbEdgeMultiTracker::getPose(c1Mo, c2Mo);
796 }
797 
806 void vpMbEdgeKltMultiTracker::getPose(const std::string &cameraName, vpHomogeneousMatrix &cMo) const
807 {
808  // We could use either the vpMbEdgeMultiTracker or vpMbKltMultiTracker class
809  vpMbEdgeMultiTracker::getPose(cameraName, cMo);
810 }
811 
817 void vpMbEdgeKltMultiTracker::getPose(std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses) const
818 {
819  // Clear the map
820  mapOfCameraPoses.clear();
821 
822  // We could use either the vpMbEdgeMultiTracker or vpMbKltMultiTracker class
823  vpMbEdgeMultiTracker::getPose(mapOfCameraPoses);
824 }
825 
827 {
828  if (!modelInitialised) {
829  throw vpException(vpTrackingException::initializationError, "model not initialized");
830  }
831 }
832 
833 #ifdef VISP_HAVE_MODULE_GUI
834 
844 void vpMbEdgeKltMultiTracker::initClick(const vpImage<unsigned char> &I, const std::vector<vpPoint> &points3D_list,
845  const std::string &displayFile)
846 {
847  // Cannot use directly set pose for KLT as it is different than for the edge
848  // case It moves the KLT points instead of detecting new KLT points
849  vpMbKltMultiTracker::initClick(I, points3D_list, displayFile);
850 
851  // Set pose for Edge (setPose or initFromPose is equivalent with
852  // vpMbEdgeTracker) And it avoids to click a second time
854 }
855 
887 void vpMbEdgeKltMultiTracker::initClick(const vpImage<unsigned char> &I, const std::string &initFile,
888  bool displayHelp, const vpHomogeneousMatrix &T)
889 {
890  // Cannot use directly set pose for KLT as it is different than for the edge
891  // case It moves the KLT points instead of detecting new KLT points
892  vpMbKltMultiTracker::initClick(I, initFile, displayHelp, T);
893 
894  // Set pose for Edge (setPose or initFromPose is equivalent with
895  // vpMbEdgeTracker) And it avoids to click a second time
897 }
898 
935  const std::string &initFile1, const std::string &initFile2,
936  bool displayHelp, bool firstCameraIsReference)
937 {
938  vpMbKltMultiTracker::initClick(I1, I2, initFile1, initFile2, displayHelp, firstCameraIsReference);
939 
940  // Get c2Mo
941  vpHomogeneousMatrix c2Mo;
942  std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.begin();
943  if (firstCameraIsReference) {
944  ++it_klt;
945  it_klt->second->getPose(c2Mo);
946  } else {
947  it_klt->second->getPose(c2Mo);
948  }
949 
950  // Set pose for Edge (setPose or initFromPose is equivalent with
951  // vpMbEdgeTracker)
952  vpMbEdgeMultiTracker::setPose(I1, I2, m_cMo, c2Mo, firstCameraIsReference);
953 }
954 
983 void vpMbEdgeKltMultiTracker::initClick(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
984  const std::string &initFile, bool displayHelp)
985 {
986  vpMbKltMultiTracker::initClick(mapOfImages, initFile, displayHelp);
987 
988  // Get pose for all the cameras
989  std::map<std::string, vpHomogeneousMatrix> mapOfCameraPoses;
990  vpMbKltMultiTracker::getPose(mapOfCameraPoses);
991 
992  // Set pose for Edge for all the cameras (setPose or initFromPose is
993  // equivalent with vpMbEdgeTracker) And it avoids to click a second time
994  vpMbEdgeMultiTracker::setPose(mapOfImages, mapOfCameraPoses);
995 }
996 
1025 void vpMbEdgeKltMultiTracker::initClick(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
1026  const std::map<std::string, std::string> &mapOfInitFiles,
1027  bool displayHelp)
1028 {
1029  vpMbKltMultiTracker::initClick(mapOfImages, mapOfInitFiles, displayHelp);
1030 
1031  // Get pose for all the cameras
1032  std::map<std::string, vpHomogeneousMatrix> mapOfCameraPoses;
1033  vpMbKltMultiTracker::getPose(mapOfCameraPoses);
1034 
1035  // Set pose for Edge for all the cameras (setPose or initFromPose is
1036  // equivalent with vpMbEdgeTracker) And it avoids to click a second time
1037  vpMbEdgeMultiTracker::setPose(mapOfImages, mapOfCameraPoses);
1038 }
1039 #endif //#ifdef VISP_HAVE_MODULE_GUI
1041 void vpMbEdgeKltMultiTracker::initCircle(const vpPoint &, const vpPoint &, const vpPoint &, const double, const int,
1042  const std::string &)
1043 {
1044  std::cerr << "The method initCircle is not used in vpMbEdgeKltMultiTracker !" << std::endl;
1045 }
1047 void vpMbEdgeKltMultiTracker::initCylinder(const vpPoint &, const vpPoint &, const double, const int,
1048  const std::string &)
1049 {
1050  std::cerr << "The method initCylinder is not used in vpMbEdgeKltMultiTracker !" << std::endl;
1051 }
1054 {
1055  std::cerr << "The method initFaceFromCorners is not used in "
1056  "vpMbEdgeKltMultiTracker !"
1057  << std::endl;
1058 }
1061 {
1062  std::cerr << "The method initFaceFromLines is not used in "
1063  "vpMbEdgeKltMultiTracker !"
1064  << std::endl;
1065 }
1066 
1085 void vpMbEdgeKltMultiTracker::initFromPose(const vpImage<unsigned char> &I, const std::string &initFile)
1086 {
1087  // Monocular case only !
1088  if (m_mapOfKltTrackers.size() > 1) {
1089  throw vpException(vpTrackingException::fatalError, "This function can only be used for the monocular case !");
1090  }
1091 
1092  char s[FILENAME_MAX];
1093  std::fstream finit;
1094  vpPoseVector init_pos;
1095 
1096  std::string ext = ".pos";
1097  size_t pos = initFile.rfind(ext);
1098 
1099  if (pos == initFile.size() - ext.size() && pos != 0)
1100  sprintf(s, "%s", initFile.c_str());
1101  else
1102  sprintf(s, "%s.pos", initFile.c_str());
1103 
1104  finit.open(s, std::ios::in);
1105  if (finit.fail()) {
1106  std::cerr << "cannot read " << s << std::endl;
1107  throw vpException(vpException::ioError, "cannot read init file");
1108  }
1109 
1110  for (unsigned int i = 0; i < 6; i += 1) {
1111  finit >> init_pos[i];
1112  }
1113 
1114  m_cMo.buildFrom(init_pos);
1117 }
1118 
1126 {
1127  // Monocular case only !
1128  if (m_mapOfKltTrackers.size() > 1) {
1129  throw vpException(vpTrackingException::fatalError, "This function can only be used for the monocular case !");
1130  }
1131 
1132  m_cMo = cMo;
1135 }
1136 
1144 {
1145  vpHomogeneousMatrix cMo(cPo);
1146  initFromPose(I, cMo);
1147 }
1148 
1160  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo,
1161  bool firstCameraIsReference)
1162 {
1163  vpMbEdgeMultiTracker::initFromPose(I1, I2, c1Mo, c2Mo, firstCameraIsReference);
1164  vpMbKltMultiTracker::initFromPose(I1, I2, c1Mo, c2Mo, firstCameraIsReference);
1165 }
1166 
1174 void vpMbEdgeKltMultiTracker::initFromPose(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
1175  const vpHomogeneousMatrix &cMo)
1176 {
1177  vpMbEdgeMultiTracker::initFromPose(mapOfImages, cMo);
1178  vpMbKltMultiTracker::initFromPose(mapOfImages, cMo);
1179 }
1180 
1187 void vpMbEdgeKltMultiTracker::initFromPose(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
1188  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses)
1189 {
1190  vpMbEdgeMultiTracker::initFromPose(mapOfImages, mapOfCameraPoses);
1191  vpMbKltMultiTracker::initFromPose(mapOfImages, mapOfCameraPoses);
1192 }
1193 
1194 unsigned int
1195 vpMbEdgeKltMultiTracker::initMbtTracking(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
1196  unsigned int lvl)
1197 {
1198  vpMbEdgeTracker *edge = NULL;
1199  unsigned int nbrows = 0;
1200 
1201  m_factor.resize(0, false);
1202  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
1203  it != m_mapOfEdgeTrackers.end(); ++it) {
1204  edge = it->second;
1205 
1206  try {
1207  edge->computeVVSInit();
1208 
1209  unsigned int nbrow = edge->m_error_edge.getRows();
1210  nbrows += nbrow;
1211 
1212  // Set the corresponding cMo for each camera
1213  // Used in computeVVSFirstPhaseFactor with computeInteractionMatrixError
1214  edge->m_cMo = m_mapOfCameraTransformationMatrix[it->first] * m_cMo;
1215 
1216  edge->computeVVSFirstPhaseFactor(*mapOfImages[it->first], lvl);
1217  m_factor.stack(edge->m_factor);
1218  } catch (...) {
1219  edge->m_L_edge.resize(0, 6, false, false);
1220  edge->m_error_edge.resize(0, false);
1221 
1222  edge->m_weightedError_edge.resize(0, false);
1223  edge->m_w_edge.resize(0, false);
1224  edge->m_factor.resize(0, false);
1225 
1226  edge->m_robustLines.resize(0);
1227  edge->m_robustCylinders.resize(0);
1228  edge->m_robustCircles.resize(0);
1229 
1230  edge->m_wLines.resize(0, false);
1231  edge->m_wCylinders.resize(0, false);
1232  edge->m_wCircles.resize(0, false);
1233 
1234  edge->m_errorLines.resize(0, false);
1235  edge->m_errorCylinders.resize(0, false);
1236  edge->m_errorCircles.resize(0, false);
1237  }
1238  }
1239 
1240  return nbrows;
1241 }
1242 
1285 void vpMbEdgeKltMultiTracker::loadConfigFile(const std::string &configFile)
1286 {
1289 }
1290 
1304 void vpMbEdgeKltMultiTracker::loadConfigFile(const std::string &configFile1, const std::string &configFile2,
1305  bool firstCameraIsReference)
1306 {
1307  vpMbEdgeMultiTracker::loadConfigFile(configFile1, configFile2, firstCameraIsReference);
1308  vpMbKltMultiTracker::loadConfigFile(configFile1, configFile2, firstCameraIsReference);
1309 }
1310 
1321 void vpMbEdgeKltMultiTracker::loadConfigFile(const std::map<std::string, std::string> &mapOfConfigFiles)
1322 {
1323  vpMbEdgeMultiTracker::loadConfigFile(mapOfConfigFiles);
1324  vpMbKltMultiTracker::loadConfigFile(mapOfConfigFiles);
1325 }
1326 
1354 void vpMbEdgeKltMultiTracker::loadModel(const std::string &modelFile, bool verbose,
1355  const vpHomogeneousMatrix &T)
1356 {
1357  vpMbEdgeMultiTracker::loadModel(modelFile, verbose, T);
1358  vpMbKltMultiTracker::loadModel(modelFile, verbose, T);
1359 
1360  modelInitialised = true;
1361 }
1363 void vpMbEdgeKltMultiTracker::postTracking(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages)
1364 {
1365  // MBT
1366  vpMbEdgeTracker *edge = NULL;
1367  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
1368  it != m_mapOfEdgeTrackers.end(); ++it) {
1369  edge = it->second;
1370 
1371  edge->updateMovingEdgeWeights();
1372 
1373  if (displayFeatures) {
1375  }
1376  }
1377 
1378  // KLT
1379  vpMbKltMultiTracker::postTracking(mapOfImages);
1380 
1381  // Looking for new visible face
1382  bool newvisibleface = false;
1383  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
1384  it != m_mapOfEdgeTrackers.end(); ++it) {
1385  edge = it->second;
1386  edge->visibleFace(*mapOfImages[it->first], it->second->m_cMo, newvisibleface);
1387  }
1388 
1389  if (useScanLine) {
1390  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
1391  it != m_mapOfEdgeTrackers.end(); ++it) {
1392  edge = it->second;
1393 
1394  edge->faces.computeClippedPolygons(it->second->m_cMo, it->second->m_cam);
1395  edge->faces.computeScanLineRender(it->second->m_cam, mapOfImages[it->first]->getWidth(),
1396  mapOfImages[it->first]->getHeight());
1397  }
1398  }
1399 
1400  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
1401  it != m_mapOfEdgeTrackers.end(); ++it) {
1402  edge = it->second;
1403  edge->updateMovingEdge(*mapOfImages[it->first]);
1404  }
1405 
1406  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
1407  it != m_mapOfEdgeTrackers.end(); ++it) {
1408  edge = it->second;
1409  edge->initMovingEdge(*mapOfImages[it->first], it->second->m_cMo);
1410 
1411  // Reinit the moving edge for the lines which need it.
1412  edge->reinitMovingEdge(*mapOfImages[it->first], it->second->m_cMo);
1413 
1414  if (computeProjError) {
1415  edge->computeProjectionError(*mapOfImages[it->first]);
1416  }
1417  }
1418 }
1420 void vpMbEdgeKltMultiTracker::reinit(/*const vpImage<unsigned char>& I */)
1421 {
1422  // vpMbEdgeMultiTracker::reinit();
1424 }
1425 
1438 void vpMbEdgeKltMultiTracker::reInitModel(const vpImage<unsigned char> &I, const std::string &cad_name,
1439  const vpHomogeneousMatrix &cMo, bool verbose,
1440  const vpHomogeneousMatrix &T)
1441 {
1442  vpMbEdgeMultiTracker::reInitModel(I, cad_name, cMo, verbose, T);
1443  vpMbKltMultiTracker::reInitModel(I, cad_name, cMo, verbose, T);
1444 }
1445 
1460  const std::string &cad_name, const vpHomogeneousMatrix &c1Mo,
1461  const vpHomogeneousMatrix &c2Mo, bool verbose,
1462  bool firstCameraIsReference)
1463 {
1464  vpMbEdgeMultiTracker::reInitModel(I1, I2, cad_name, c1Mo, c2Mo, verbose, firstCameraIsReference);
1465  vpMbKltMultiTracker::reInitModel(I1, I2, cad_name, c1Mo, c2Mo, verbose, firstCameraIsReference);
1466 }
1467 
1478 void vpMbEdgeKltMultiTracker::reInitModel(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
1479  const std::string &cad_name,
1480  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses,
1481  bool verbose)
1482 {
1483  vpMbEdgeMultiTracker::reInitModel(mapOfImages, cad_name, mapOfCameraPoses, verbose);
1484  vpMbKltMultiTracker::reInitModel(mapOfImages, cad_name, mapOfCameraPoses, verbose);
1485 }
1486 
1492 {
1495 }
1496 
1506 void vpMbEdgeKltMultiTracker::setAngleAppear(const double &a)
1507 {
1510 }
1511 
1521 void vpMbEdgeKltMultiTracker::setAngleDisappear(const double &a)
1522 {
1525 }
1526 
1533 {
1536 
1537  m_cam = cam;
1538 }
1539 
1549  bool firstCameraIsReference)
1550 {
1551  vpMbEdgeMultiTracker::setCameraParameters(camera1, camera2, firstCameraIsReference);
1552  vpMbKltMultiTracker::setCameraParameters(camera1, camera2, firstCameraIsReference);
1553 
1554  if (firstCameraIsReference) {
1555  m_cam = camera1;
1556  } else {
1557  m_cam = camera2;
1558  }
1559 }
1560 
1567 void vpMbEdgeKltMultiTracker::setCameraParameters(const std::string &cameraName, const vpCameraParameters &cam)
1568 {
1571 
1572  if (cameraName == m_referenceCameraName) {
1573  m_cam = cam;
1574  }
1575 }
1576 
1583  const std::map<std::string, vpCameraParameters> &mapOfCameraParameters)
1584 {
1585  vpMbEdgeMultiTracker::setCameraParameters(mapOfCameraParameters);
1586  vpMbKltMultiTracker::setCameraParameters(mapOfCameraParameters);
1587 
1588  for (std::map<std::string, vpCameraParameters>::const_iterator it = mapOfCameraParameters.begin();
1589  it != mapOfCameraParameters.end(); ++it) {
1590  if (it->first == m_referenceCameraName) {
1591  m_cam = it->second;
1592  }
1593  }
1594 }
1595 
1604 void vpMbEdgeKltMultiTracker::setCameraTransformationMatrix(const std::string &cameraName,
1605  const vpHomogeneousMatrix &cameraTransformationMatrix)
1606 {
1607  vpMbEdgeMultiTracker::setCameraTransformationMatrix(cameraName, cameraTransformationMatrix);
1608  vpMbKltMultiTracker::setCameraTransformationMatrix(cameraName, cameraTransformationMatrix);
1609 
1610  std::map<std::string, vpHomogeneousMatrix>::iterator it = m_mapOfCameraTransformationMatrix.find(cameraName);
1611  if (it != m_mapOfCameraTransformationMatrix.end()) {
1612  it->second = cameraTransformationMatrix;
1613  } else {
1614  std::cerr << "Cannot find camera: " << cameraName << " !" << std::endl;
1615  }
1616 }
1617 
1626  const std::map<std::string, vpHomogeneousMatrix> &mapOfTransformationMatrix)
1627 {
1628  vpMbEdgeMultiTracker::setCameraTransformationMatrix(mapOfTransformationMatrix);
1629  vpMbKltMultiTracker::setCameraTransformationMatrix(mapOfTransformationMatrix);
1630 
1631  m_mapOfCameraTransformationMatrix = mapOfTransformationMatrix;
1632 }
1633 
1641 void vpMbEdgeKltMultiTracker::setClipping(const unsigned int &flags)
1642 {
1645 }
1646 
1655 void vpMbEdgeKltMultiTracker::setClipping(const std::string &cameraName, const unsigned int &flags)
1656 {
1657  // Here, we do not change the general clipping flag
1658  vpMbEdgeMultiTracker::setClipping(cameraName, flags);
1659  vpMbKltMultiTracker::setClipping(cameraName, flags);
1660 }
1661 
1668 {
1671 }
1672 
1689 {
1692 }
1693 
1699 void vpMbEdgeKltMultiTracker::setFarClippingDistance(const double &dist)
1700 {
1703 }
1704 
1711 void vpMbEdgeKltMultiTracker::setFarClippingDistance(const std::string &cameraName, const double &dist)
1712 {
1715 }
1716 
1717 #ifdef VISP_HAVE_OGRE
1718 
1728 {
1731 }
1732 
1742 void vpMbEdgeKltMultiTracker::setNbRayCastingAttemptsForVisibility(const unsigned int &attempts)
1743 {
1746 }
1747 #endif
1748 
1760 void vpMbEdgeKltMultiTracker::setLod(bool useLod, const std::string &name)
1761 {
1762  vpMbEdgeMultiTracker::setLod(useLod, name);
1763  vpMbKltMultiTracker::setLod(useLod, name);
1764 }
1765 
1778 void vpMbEdgeKltMultiTracker::setLod(bool useLod, const std::string &cameraName, const std::string &name)
1779 {
1780  vpMbEdgeMultiTracker::setLod(useLod, cameraName, name);
1781  vpMbKltMultiTracker::setLod(useLod, cameraName, name);
1782 }
1783 
1793 void vpMbEdgeKltMultiTracker::setMinLineLengthThresh(double minLineLengthThresh, const std::string &name)
1794 {
1795  vpMbEdgeMultiTracker::setMinLineLengthThresh(minLineLengthThresh, name);
1796 }
1797 
1809 void vpMbEdgeKltMultiTracker::setMinLineLengthThresh(double minLineLengthThresh, const std::string &cameraName,
1810  const std::string &name)
1811 {
1812  vpMbEdgeMultiTracker::setMinLineLengthThresh(minLineLengthThresh, cameraName, name);
1813 }
1814 
1823 void vpMbEdgeKltMultiTracker::setMinPolygonAreaThresh(double minPolygonAreaThresh, const std::string &name)
1824 {
1825  vpMbEdgeMultiTracker::setMinPolygonAreaThresh(minPolygonAreaThresh, name);
1826  vpMbKltMultiTracker::setMinPolygonAreaThresh(minPolygonAreaThresh, name);
1827 }
1828 
1839 void vpMbEdgeKltMultiTracker::setMinPolygonAreaThresh(double minPolygonAreaThresh, const std::string &cameraName,
1840  const std::string &name)
1841 {
1842  vpMbEdgeMultiTracker::setMinPolygonAreaThresh(minPolygonAreaThresh, cameraName, name);
1843  vpMbKltMultiTracker::setMinPolygonAreaThresh(minPolygonAreaThresh, cameraName, name);
1844 }
1845 
1851 void vpMbEdgeKltMultiTracker::setNearClippingDistance(const double &dist)
1852 {
1855 }
1856 
1863 void vpMbEdgeKltMultiTracker::setNearClippingDistance(const std::string &cameraName, const double &dist)
1864 {
1867 }
1868 
1879 void vpMbEdgeKltMultiTracker::setOgreShowConfigDialog(bool showConfigDialog)
1880 {
1883 }
1884 
1894 {
1895  // Edge
1896  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
1897  it != m_mapOfEdgeTrackers.end(); ++it) {
1898  it->second->setOgreVisibilityTest(v);
1899  }
1900 
1901 #ifdef VISP_HAVE_OGRE
1902  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
1903  it != m_mapOfEdgeTrackers.end(); ++it) {
1904  it->second->faces.getOgreContext()->setWindowName("Multi Edge MBT Hybrid (" + it->first + ")");
1905  }
1906 #endif
1907 
1908  // KLT
1909  for (std::map<std::string, vpMbKltTracker *>::const_iterator it = m_mapOfKltTrackers.begin();
1910  it != m_mapOfKltTrackers.end(); ++it) {
1911  it->second->setOgreVisibilityTest(v);
1912  }
1913 
1914 #ifdef VISP_HAVE_OGRE
1915  for (std::map<std::string, vpMbKltTracker *>::const_iterator it = m_mapOfKltTrackers.begin();
1916  it != m_mapOfKltTrackers.end(); ++it) {
1917  it->second->faces.getOgreContext()->setWindowName("Multi KLT MBT Hybrid (" + it->first + ")");
1918  }
1919 #endif
1920 
1921  useOgre = v;
1922 }
1923 
1929 void vpMbEdgeKltMultiTracker::setOptimizationMethod(const vpMbtOptimizationMethod &opt)
1930 {
1933 }
1934 
1943 {
1944  if (m_mapOfEdgeTrackers.size() != 1 || m_mapOfKltTrackers.size() != 1) {
1945  std::cerr << "This method requires only 1 camera !" << std::endl;
1946  } else {
1947  std::map<std::string, vpMbEdgeTracker *>::const_iterator it_edge = m_mapOfEdgeTrackers.find(m_referenceCameraName);
1948  std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.find(m_referenceCameraName);
1949  if (it_edge != m_mapOfEdgeTrackers.end() && it_klt != m_mapOfKltTrackers.end()) {
1950  it_edge->second->setPose(I, cMo);
1951  it_klt->second->setPose(I, cMo);
1952 
1953  m_cMo = cMo;
1954  c0Mo = m_cMo;
1955  ctTc0.eye();
1956  } else {
1957  std::cerr << "Cannot find the reference camera: " << m_referenceCameraName << " !" << std::endl;
1958  }
1959  }
1960 }
1961 
1970 {
1971  if (m_mapOfEdgeTrackers.size() != 1 || m_mapOfKltTrackers.size() != 1) {
1972  std::cerr << "This method requires only 1 camera !" << std::endl;
1973  } else {
1974  std::map<std::string, vpMbEdgeTracker *>::const_iterator it_edge = m_mapOfEdgeTrackers.find(m_referenceCameraName);
1975  std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.find(m_referenceCameraName);
1976  if (it_edge != m_mapOfEdgeTrackers.end() && it_klt != m_mapOfKltTrackers.end()) {
1977  vpImageConvert::convert(I_color, m_I);
1978  it_edge->second->setPose(m_I, cMo);
1979  it_klt->second->setPose(m_I, cMo);
1980 
1981  m_cMo = cMo;
1982  c0Mo = m_cMo;
1983  ctTc0.eye();
1984  } else {
1985  std::cerr << "Cannot find the reference camera: " << m_referenceCameraName << " !" << std::endl;
1986  }
1987  }
1988 }
1989 
2002  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo,
2003  bool firstCameraIsReference)
2004 {
2005  vpMbEdgeMultiTracker::setPose(I1, I2, c1Mo, c2Mo, firstCameraIsReference);
2006  vpMbKltMultiTracker::setPose(I1, I2, c1Mo, c2Mo, firstCameraIsReference);
2007 }
2008 
2017 void vpMbEdgeKltMultiTracker::setPose(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
2018  const vpHomogeneousMatrix &cMo)
2019 {
2020  vpMbEdgeMultiTracker::setPose(mapOfImages, cMo);
2021  vpMbKltMultiTracker::setPose(mapOfImages, cMo);
2022 }
2023 
2034 void vpMbEdgeKltMultiTracker::setPose(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
2035  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses)
2036 {
2037  vpMbEdgeMultiTracker::setPose(mapOfImages, mapOfCameraPoses);
2038  vpMbKltMultiTracker::setPose(mapOfImages, mapOfCameraPoses);
2039 }
2040 
2048 {
2049  // Set the general flag for the current class
2051 
2052  // Set the flag for each camera
2053  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
2054  it != m_mapOfEdgeTrackers.end(); ++it) {
2055  it->second->setProjectionErrorComputation(flag);
2056  }
2057 }
2058 
2064 void vpMbEdgeKltMultiTracker::setReferenceCameraName(const std::string &referenceCameraName)
2065 {
2066  vpMbEdgeMultiTracker::setReferenceCameraName(referenceCameraName);
2067  vpMbKltMultiTracker::setReferenceCameraName(referenceCameraName);
2068  m_referenceCameraName = referenceCameraName;
2069 }
2070 
2077 {
2080 }
2081 
2088 {
2090 }
2093 {
2094  std::cerr << "The method vpMbEdgeKltMultiTracker::testTracking is not used !" << std::endl;
2095 }
2096 
2105 {
2106  // Track only with reference camera
2107  // Get the reference camera parameters
2108  std::map<std::string, vpMbEdgeTracker *>::const_iterator it_mbt = m_mapOfEdgeTrackers.find(m_referenceCameraName);
2109  std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.find(m_referenceCameraName);
2110 
2111  if (it_mbt != m_mapOfEdgeTrackers.end() && it_klt != m_mapOfKltTrackers.end()) {
2112  std::map<std::string, const vpImage<unsigned char> *> mapOfImages;
2113  mapOfImages[m_referenceCameraName] = &I;
2114  track(mapOfImages);
2115  } else {
2116  std::stringstream ss;
2117  ss << "The reference camera: " << m_referenceCameraName << " does not exist !";
2118  throw vpException(vpTrackingException::fatalError, ss.str().c_str());
2119  }
2120 
2121  // Set the projection error from the single camera
2122  if (computeProjError) {
2123  projectionError = it_mbt->second->getProjectionError();
2124  }
2125 }
2126 
2131 {
2132  std::cout << "Not supported interface, this class is deprecated." << std::endl;
2133 }
2134 
2144 {
2145  if (m_mapOfEdgeTrackers.size() == 2 && m_mapOfKltTrackers.size() == 2) {
2146  std::map<std::string, vpMbKltTracker *>::const_iterator it = m_mapOfKltTrackers.begin();
2147  std::map<std::string, const vpImage<unsigned char> *> mapOfImages;
2148  // Assume that the first image is the first name in alphabetic order
2149  mapOfImages[it->first] = &I1;
2150  ++it;
2151 
2152  mapOfImages[it->first] = &I2;
2153  track(mapOfImages);
2154  } else {
2155  std::stringstream ss;
2156  ss << "Require two cameras ! There are " << m_mapOfKltTrackers.size() << " cameras !";
2157  throw vpException(vpTrackingException::fatalError, ss.str().c_str());
2158  }
2159 }
2160 
2168 void vpMbEdgeKltMultiTracker::track(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages)
2169 {
2170  // Reset the projectionError
2171  projectionError = 90.0;
2172 
2173  // Check if there is an image for each camera
2174  // mbt
2175  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it_edge = m_mapOfEdgeTrackers.begin();
2176  it_edge != m_mapOfEdgeTrackers.end(); ++it_edge) {
2177  std::map<std::string, const vpImage<unsigned char> *>::const_iterator it_img = mapOfImages.find(it_edge->first);
2178 
2179  if (it_img == mapOfImages.end()) {
2180  throw vpException(vpTrackingException::fatalError, "Missing images for edge trackers !");
2181  }
2182  }
2183 
2184  // klt
2185  for (std::map<std::string, vpMbKltTracker *>::const_iterator it_klt = m_mapOfKltTrackers.begin();
2186  it_klt != m_mapOfKltTrackers.end(); ++it_klt) {
2187  std::map<std::string, const vpImage<unsigned char> *>::const_iterator it_img = mapOfImages.find(it_klt->first);
2188 
2189  if (it_img == mapOfImages.end()) {
2190  throw vpException(vpTrackingException::fatalError, "Missing images for KLT trackers !");
2191  }
2192  }
2193 
2194  try {
2195  vpMbKltMultiTracker::preTracking(mapOfImages);
2196  } catch (...) {
2197  }
2198 
2199  // MBT: track moving edges
2200  trackMovingEdges(mapOfImages);
2201 
2202  computeVVS(mapOfImages);
2203 
2204  postTracking(mapOfImages);
2205 
2206  if (computeProjError) {
2208  }
2209 }
2211 void vpMbEdgeKltMultiTracker::trackMovingEdges(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages)
2212 {
2213  for (std::map<std::string, vpMbEdgeTracker *>::const_iterator it = m_mapOfEdgeTrackers.begin();
2214  it != m_mapOfEdgeTrackers.end(); ++it) {
2215  vpMbEdgeTracker *edge = it->second;
2216  // Track moving edges
2217  try {
2218  edge->trackMovingEdge(*mapOfImages[it->first]);
2219  } catch (...) {
2220  std::cerr << "Error in moving edge tracking" << std::endl;
2221  throw;
2222  }
2223  }
2224 }
2225 
2226 #elif !defined(VISP_BUILD_SHARED_LIBS)
2227 // Work arround to avoid warning:
2228 // libvisp_mbt.a(dummy_vpMbEdgeKltMultiTracker.cpp.o) has no symbols
2229 void dummy_vpMbEdgeKltMultiTracker(){}
2230 #endif // VISP_HAVE_OPENCV
2231 #elif !defined(VISP_BUILD_SHARED_LIBS)
2232 // Work arround to avoid warning:
2233 // libvisp_mbt.a(dummy_vpMbEdgeKltMultiTracker.cpp.o) has no symbols
2234 void dummy_vpMbEdgeKltMultiTracker(){}
2235 #endif //#if defined(VISP_BUILD_DEPRECATED_FUNCTIONS)
vpMbtDistanceKltPoints::hasEnoughPoints
bool hasEnoughPoints() const
Definition: vpMbtDistanceKltPoints.h:190
vpTrackingException
Error that can be emited by the vpTracker class and its derivates.
Definition: vpTrackingException.h:68
vpMbEdgeKltMultiTracker::setNbRayCastingAttemptsForVisibility
void setNbRayCastingAttemptsForVisibility(const unsigned int &attempts)
Definition: vpMbEdgeKltMultiTracker.cpp:1741
vpMbKltMultiTracker::resetTracker
virtual void resetTracker()
Definition: vpMbKltMultiTracker.cpp:1894
vpMbEdgeTracker::m_error_edge
vpColVector m_error_edge
(s - s*)
Definition: vpMbEdgeTracker.h:324
vpMbKltMultiTracker::reinit
virtual void reinit()
Definition: vpMbKltMultiTracker.cpp:1741
vpMbEdgeTracker::m_weightedError_edge
vpColVector m_weightedError_edge
Weighted error.
Definition: vpMbEdgeTracker.h:328
vpMbEdgeKltMultiTracker::computeVVSInit
virtual void computeVVSInit()
Definition: vpMbEdgeKltMultiTracker.cpp:246
vpMbTracker::setProjectionErrorComputation
virtual void setProjectionErrorComputation(const bool &flag)
Definition: vpMbTracker.h:579
vpMbEdgeMultiTracker::setAngleAppear
virtual void setAngleAppear(const double &a)
Definition: vpMbEdgeMultiTracker.cpp:2033
vpMbKltMultiTracker::setLod
virtual void setLod(bool useLod, const std::string &name="")
Definition: vpMbKltMultiTracker.cpp:2291
vpMbEdgeMultiTracker::computeProjectionError
virtual void computeProjectionError()
Definition: vpMbEdgeMultiTracker.cpp:162
vpMbEdgeKltMultiTracker::getEdgeMultiNbPolygon
virtual std::map< std::string, unsigned int > getEdgeMultiNbPolygon() const
Definition: vpMbEdgeKltMultiTracker.cpp:769
vpMbTracker::m_computeInteraction
bool m_computeInteraction
Definition: vpMbTracker.h:184
vpMbEdgeKltMultiTracker::getKltFaces
std::map< std::string, vpMbHiddenFaces< vpMbtPolygon > > getKltFaces() const
Definition: vpMbEdgeKltMultiTracker.cpp:750
vpMbEdgeMultiTracker::setOptimizationMethod
virtual void setOptimizationMethod(const vpMbtOptimizationMethod &opt)
Definition: vpMbEdgeMultiTracker.cpp:2608
vpMbEdgeMultiTracker::display
virtual void display(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const vpColor &col, unsigned int thickness=1, bool displayFullModel=false)
Definition: vpMbEdgeMultiTracker.cpp:505
vpMbEdgeTracker::m_robustCircles
vpRobust m_robustCircles
Definition: vpMbEdgeTracker.h:314
vpMbEdgeTracker::m_factor
vpColVector m_factor
Edge VVS variables.
Definition: vpMbEdgeTracker.h:311
vpMbKltTracker::m_w_klt
vpColVector m_w_klt
Robust weights.
Definition: vpMbKltTracker.h:260
vpMbEdgeKltMultiTracker::vpMbEdgeKltMultiTracker
vpMbEdgeKltMultiTracker()
Definition: vpMbEdgeKltMultiTracker.cpp:56
vpMbEdgeKltMultiTracker::trackMovingEdges
virtual void trackMovingEdges(std::map< std::string, const vpImage< unsigned char > * > &mapOfImages)
Definition: vpMbEdgeKltMultiTracker.cpp:2210
vpMbEdgeKltMultiTracker::m_mapOfCameraTransformationMatrix
std::map< std::string, vpHomogeneousMatrix > m_mapOfCameraTransformationMatrix
Definition: vpMbEdgeKltMultiTracker.h:90
vpMath::sqr
static double sqr(double x)
Definition: vpMath.h:113
vpMbEdgeKltMultiTracker::initClick
virtual void initClick(const vpImage< unsigned char > &I, const std::vector< vpPoint > &points3D_list, const std::string &displayFile="")
Definition: vpMbEdgeKltMultiTracker.cpp:843
vpMbTracker::m_cMo
vpHomogeneousMatrix m_cMo
The current pose.
Definition: vpMbTracker.h:112
vpMbKltTracker::m_error_klt
vpColVector m_error_klt
(s - s*)
Definition: vpMbKltTracker.h:258
vpMbEdgeKltMultiTracker::m_w_hybridMulti
vpColVector m_w_hybridMulti
Robust weights.
Definition: vpMbEdgeKltMultiTracker.h:101
vpMbEdgeTracker::m_featuresToBeDisplayedEdge
std::vector< std::vector< double > > m_featuresToBeDisplayedEdge
Display features.
Definition: vpMbEdgeTracker.h:332
vpMbEdgeKltMultiTracker::setReferenceCameraName
virtual void setReferenceCameraName(const std::string &referenceCameraName)
Definition: vpMbEdgeKltMultiTracker.cpp:2063
vpMbEdgeKltMultiTracker::setPose
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo)
Definition: vpMbEdgeKltMultiTracker.cpp:1941
vpMbEdgeKltMultiTracker::initCircle
virtual void initCircle(const vpPoint &, const vpPoint &, const vpPoint &, const double, const int, const std::string &name="")
Definition: vpMbEdgeKltMultiTracker.cpp:1040
vpMbTracker::m_cam
vpCameraParameters m_cam
The camera parameters.
Definition: vpMbTracker.h:110
vpMbEdgeMultiTracker::setAngleDisappear
virtual void setAngleDisappear(const double &a)
Definition: vpMbEdgeMultiTracker.cpp:2052
vpMbEdgeTracker::computeVVSWeights
virtual void computeVVSWeights()
Definition: vpMbEdgeTracker.cpp:839
vpMbEdgeKltMultiTracker::setMinPolygonAreaThresh
virtual void setMinPolygonAreaThresh(double minPolygonAreaThresh, const std::string &name="")
Definition: vpMbEdgeKltMultiTracker.cpp:1822
vpMbEdgeMultiTracker::setMinLineLengthThresh
virtual void setMinLineLengthThresh(double minLineLengthThresh, const std::string &name="")
Definition: vpMbEdgeMultiTracker.cpp:2431
vpMbEdgeKltMultiTracker::loadModel
virtual void loadModel(const std::string &modelFile, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbEdgeKltMultiTracker.cpp:1353
vpMbHiddenFaces::computeClippedPolygons
void computeClippedPolygons(const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam)
Definition: vpMbHiddenFaces.h:440
vpMbEdgeTracker::visibleFace
void visibleFace(const vpImage< unsigned char > &_I, const vpHomogeneousMatrix &_cMo, bool &newvisibleline)
Definition: vpMbEdgeTracker.cpp:2218
vpMbEdgeTracker
Make the complete tracking of an object by using its CAD model.
Definition: vpMbEdgeTracker.h:257
vpMbKltMultiTracker::setNbRayCastingAttemptsForVisibility
void setNbRayCastingAttemptsForVisibility(const unsigned int &attempts)
Definition: vpMbKltMultiTracker.cpp:2240
vpMbTracker::useOgre
bool useOgre
Use Ogre3d for visibility tests.
Definition: vpMbTracker.h:154
vpMbTracker::computeVVSCheckLevenbergMarquardt
virtual void computeVVSCheckLevenbergMarquardt(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:2902
vpImageConvert::convert
static void convert(const vpImage< unsigned char > &src, vpImage< vpRGBa > &dest)
Definition: vpImageConvert.cpp:78
vpMbEdgeTracker::m_errorCircles
vpColVector m_errorCircles
Definition: vpMbEdgeTracker.h:320
vpMbKltMultiTracker::loadModel
virtual void loadModel(const std::string &modelFile, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbKltMultiTracker.cpp:1685
vpMatrix::insert
void insert(const vpMatrix &A, unsigned int r, unsigned int c)
Definition: vpMatrix.cpp:4908
vpMbtDistanceKltPoints
Implementation of a polygon of the model containing points of interest. It is used by the model-based...
Definition: vpMbtDistanceKltPoints.h:66
vpMbKltMultiTracker::setReferenceCameraName
virtual void setReferenceCameraName(const std::string &referenceCameraName)
Definition: vpMbKltMultiTracker.cpp:2695
vpMbTracker::getClipping
virtual unsigned int getClipping() const
Definition: vpMbTracker.h:251
vpMbEdgeKltMultiTracker::setGoodNbRayCastingAttemptsRatio
void setGoodNbRayCastingAttemptsRatio(const double &ratio)
Definition: vpMbEdgeKltMultiTracker.cpp:1726
vpCameraParameters
Generic class defining intrinsic camera parameters.
Definition: vpCameraParameters.h:232
vpMbKltTracker
Model based tracker using only KLT.
Definition: vpMbKltTracker.h:215
vpMbEdgeTracker::m_errorLines
vpColVector m_errorLines
Definition: vpMbEdgeTracker.h:318
vpMbtDistanceKltCylinder::displayPrimitive
void displayPrimitive(const vpImage< unsigned char > &_I)
Definition: vpMbtDistanceKltCylinder.cpp:531
vpMbEdgeTracker::trackMovingEdge
void trackMovingEdge(const vpImage< unsigned char > &I)
Definition: vpMbEdgeTracker.cpp:1635
vpMbtDistanceKltCylinder
Implementation of a polygon of the model containing points of interest. It is used by the model-based...
Definition: vpMbtDistanceKltCylinder.h:67
vpMbEdgeTracker::getFeaturesForDisplayEdge
virtual std::vector< std::vector< double > > getFeaturesForDisplayEdge()
Definition: vpMbEdgeTracker.cpp:1363
vpMbKltTracker::m_L_klt
vpMatrix m_L_klt
Interaction matrix.
Definition: vpMbKltTracker.h:256
vpMbEdgeKltMultiTracker::getFaces
virtual vpMbHiddenFaces< vpMbtPolygon > & getFaces()
Definition: vpMbEdgeKltMultiTracker.cpp:703
vpMbEdgeMultiTracker::setMinPolygonAreaThresh
virtual void setMinPolygonAreaThresh(double minPolygonAreaThresh, const std::string &name="")
Definition: vpMbEdgeMultiTracker.cpp:2470
vpMbtDistanceKltCylinder::hasEnoughPoints
bool hasEnoughPoints() const
Definition: vpMbtDistanceKltCylinder.h:188
vpMbEdgeMultiTracker::setCameraTransformationMatrix
virtual void setCameraTransformationMatrix(const std::string &cameraName, const vpHomogeneousMatrix &cameraTransformationMatrix)
Definition: vpMbEdgeMultiTracker.cpp:2174
vpMbEdgeKltMultiTracker::init
virtual void init(const vpImage< unsigned char > &I)
Definition: vpMbEdgeKltMultiTracker.cpp:825
vpMbEdgeKltMultiTracker::display
virtual void display(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const vpColor &col, unsigned int thickness=1, bool displayFullModel=false)
Definition: vpMbEdgeKltMultiTracker.cpp:361
vpMbEdgeKltMultiTracker::setAngleDisappear
virtual void setAngleDisappear(const double &a)
Definition: vpMbEdgeKltMultiTracker.cpp:1520
vpMbEdgeTracker::initMovingEdge
void initMovingEdge(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &_cMo)
Definition: vpMbEdgeTracker.cpp:1522
vpMbKltMultiTracker::setDisplayFeatures
virtual void setDisplayFeatures(bool displayF)
Definition: vpMbKltMultiTracker.cpp:2172
vpMbKltMultiTracker::getFaces
virtual vpMbHiddenFaces< vpMbtPolygon > & getFaces()
Definition: vpMbKltMultiTracker.cpp:585
vpMbKltMultiTracker::computeVVS
virtual void computeVVS()
Definition: vpMbKltMultiTracker.cpp:157
vpHomogeneousMatrix::eye
void eye()
Definition: vpHomogeneousMatrix.cpp:661
vpException::fatalError
Fatal error.
Definition: vpException.h:95
vpMbEdgeKltMultiTracker::m_factorMBT
double m_factorMBT
Factor for edge trackers.
Definition: vpMbEdgeKltMultiTracker.h:82
vpMbTracker::computeCovariance
bool computeCovariance
Flag used to specify if the covariance matrix has to be computed or not.
Definition: vpMbTracker.h:127
vpException::ioError
I/O error.
Definition: vpException.h:90
vpMbEdgeKltMultiTracker::m_nbrow
unsigned int m_nbrow
Number of features.
Definition: vpMbEdgeKltMultiTracker.h:95
vpMbTracker::modelInitialised
bool modelInitialised
Definition: vpMbTracker.h:122
vpMbTracker::getPose
virtual vpHomogeneousMatrix getPose() const
Definition: vpMbTracker.h:418
vpMbHiddenFaces< vpMbtPolygon >
vpMbTracker::faces
vpMbHiddenFaces< vpMbtPolygon > faces
Set of faces describing the object.
Definition: vpMbTracker.h:142
vpMbEdgeKltMultiTracker::setOptimizationMethod
virtual void setOptimizationMethod(const vpMbtOptimizationMethod &opt)
Definition: vpMbEdgeKltMultiTracker.cpp:1928
vpMbEdgeKltMultiTracker::initFaceFromLines
virtual void initFaceFromLines(vpMbtPolygon &polygon)
Definition: vpMbEdgeKltMultiTracker.cpp:1059
vpMbEdgeMultiTracker::initFromPose
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
Definition: vpMbEdgeMultiTracker.cpp:1515
vpMbEdgeTracker::m_robustLines
vpRobust m_robustLines
Definition: vpMbEdgeTracker.h:312
vpMbEdgeKltMultiTracker::setCovarianceComputation
virtual void setCovarianceComputation(const bool &flag)
Definition: vpMbEdgeKltMultiTracker.cpp:1666
vpMbEdgeTracker::m_wCircles
vpColVector m_wCircles
Definition: vpMbEdgeTracker.h:317
vpMbEdgeKltMultiTracker::computeVVSInteractionMatrixAndResidu
virtual void computeVVSInteractionMatrixAndResidu()
Definition: vpMbEdgeKltMultiTracker.cpp:264
vpMbKltTracker::computeVVSInit
virtual void computeVVSInit()
Definition: vpMbKltTracker.cpp:859
vpMbEdgeKltMultiTracker::~vpMbEdgeKltMultiTracker
virtual ~vpMbEdgeKltMultiTracker()
Definition: vpMbEdgeKltMultiTracker.cpp:122
vpMbEdgeMultiTracker::setNbRayCastingAttemptsForVisibility
void setNbRayCastingAttemptsForVisibility(const unsigned int &attempts)
Definition: vpMbEdgeMultiTracker.cpp:2371
vpMbEdgeKltMultiTracker::initFaceFromCorners
virtual void initFaceFromCorners(vpMbtPolygon &polygon)
Definition: vpMbEdgeKltMultiTracker.cpp:1052
vpMbEdgeKltMultiTracker::setFarClippingDistance
virtual void setFarClippingDistance(const double &dist)
Definition: vpMbEdgeKltMultiTracker.cpp:1698
vpMbEdgeKltMultiTracker::initMbtTracking
virtual unsigned int initMbtTracking(std::map< std::string, const vpImage< unsigned char > * > &mapOfImages, unsigned int lvl)
Definition: vpMbEdgeKltMultiTracker.cpp:1194
vpMbEdgeKltMultiTracker::m_error_hybridMulti
vpColVector m_error_hybridMulti
(s - s*)
Definition: vpMbEdgeKltMultiTracker.h:99
vpMbKltMultiTracker::setMinPolygonAreaThresh
virtual void setMinPolygonAreaThresh(double minPolygonAreaThresh, const std::string &name="")
Definition: vpMbKltMultiTracker.cpp:2353
vpTrackingException::notEnoughPointError
Definition: vpTrackingException.h:79
vpMbEdgeTracker::reinitMovingEdge
void reinitMovingEdge(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &_cMo)
Definition: vpMbEdgeTracker.cpp:1878
vpMbEdgeMultiTracker::setOgreShowConfigDialog
virtual void setOgreShowConfigDialog(bool showConfigDialog)
Definition: vpMbEdgeMultiTracker.cpp:2570
vpMbtDistanceKltPoints::displayPrimitive
void displayPrimitive(const vpImage< unsigned char > &_I)
Definition: vpMbtDistanceKltPoints.cpp:544
vpMbKltTracker::computeVVSInteractionMatrixAndResidu
virtual void computeVVSInteractionMatrixAndResidu()
Definition: vpMbKltTracker.cpp:874
vpMbEdgeKltMultiTracker::m_L_hybridMulti
vpMatrix m_L_hybridMulti
Interaction matrix.
Definition: vpMbEdgeKltMultiTracker.h:97
vpMbEdgeMultiTracker::setLod
virtual void setLod(bool useLod, const std::string &name="")
Definition: vpMbEdgeMultiTracker.cpp:2391
vpMbKltMultiTracker::setAngleDisappear
virtual void setAngleDisappear(const double &a)
Definition: vpMbKltMultiTracker.cpp:1958
vpMbEdgeTracker::updateMovingEdge
void updateMovingEdge(const vpImage< unsigned char > &I)
Definition: vpMbEdgeTracker.cpp:1678
vpMbEdgeKltMultiTracker::computeVVSWeights
virtual void computeVVSWeights()
Definition: vpMbEdgeKltMultiTracker.cpp:323
vpMbEdgeMultiTracker::setFarClippingDistance
virtual void setFarClippingDistance(const double &dist)
Definition: vpMbEdgeMultiTracker.cpp:2295
vpMbEdgeTracker::m_w_edge
vpColVector m_w_edge
Robust weights.
Definition: vpMbEdgeTracker.h:326
vpMbKltMultiTracker::setFarClippingDistance
virtual void setFarClippingDistance(const double &dist)
Definition: vpMbKltMultiTracker.cpp:2187
vpMbEdgeKltMultiTracker::m_weightedError_hybridMulti
vpColVector m_weightedError_hybridMulti
Weighted error.
Definition: vpMbEdgeKltMultiTracker.h:103
vpMbEdgeKltMultiTracker::setMinLineLengthThresh
virtual void setMinLineLengthThresh(double minLineLengthThresh, const std::string &name="")
Definition: vpMbEdgeKltMultiTracker.cpp:1792
vpMbEdgeMultiTracker::setCameraParameters
virtual void setCameraParameters(const vpCameraParameters &camera)
Definition: vpMbEdgeMultiTracker.cpp:2067
vpMbEdgeMultiTracker::setCovarianceComputation
virtual void setCovarianceComputation(const bool &flag)
Definition: vpMbEdgeMultiTracker.cpp:2254
vpMbEdgeKltMultiTracker::setAngleAppear
virtual void setAngleAppear(const double &a)
Definition: vpMbEdgeKltMultiTracker.cpp:1505
vpMbEdgeTracker::m_robustCylinders
vpRobust m_robustCylinders
Definition: vpMbEdgeTracker.h:313
vpMbEdgeKltMultiTracker::postTracking
virtual void postTracking(std::map< std::string, const vpImage< unsigned char > * > &mapOfImages)
Definition: vpMbEdgeKltMultiTracker.cpp:1362
vpMbEdgeMultiTracker::loadModel
virtual void loadModel(const std::string &modelFile, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbEdgeMultiTracker.cpp:1845
vpMbEdgeKltMultiTracker::reinit
virtual void reinit()
Definition: vpMbEdgeKltMultiTracker.cpp:1419
vpMbKltMultiTracker::setPose
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo)
Definition: vpMbKltMultiTracker.cpp:2479
vpColVector
Implementation of column vector and the associated operations.
Definition: vpColVector.h:129
vpMbTracker::useScanLine
bool useScanLine
Use Scanline for visibility tests.
Definition: vpMbTracker.h:157
vpMbEdgeMultiTracker::setReferenceCameraName
virtual void setReferenceCameraName(const std::string &referenceCameraName)
Definition: vpMbEdgeMultiTracker.cpp:2844
vpMbEdgeMultiTracker::setGoodNbRayCastingAttemptsRatio
void setGoodNbRayCastingAttemptsRatio(const double &ratio)
Definition: vpMbEdgeMultiTracker.cpp:2354
vpMbTracker::projectionError
double projectionError
Definition: vpMbTracker.h:135
vpTrackingException::fatalError
Definition: vpTrackingException.h:81
vpMbEdgeKltMultiTracker::loadConfigFile
virtual void loadConfigFile(const std::string &configFile)
Definition: vpMbEdgeKltMultiTracker.cpp:1284
vpMbEdgeMultiTracker
Make the complete stereo (or more) tracking of an object by using its CAD model.
Definition: vpMbEdgeMultiTracker.h:72
vpMatrix
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:163
vpMbtDistanceKltPoints::isTracked
bool isTracked() const
Definition: vpMbtDistanceKltPoints.h:199
vpMbKltMultiTracker::setScanLineVisibilityTest
virtual void setScanLineVisibilityTest(const bool &v)
Definition: vpMbKltMultiTracker.cpp:2712
vpMbEdgeKltMultiTracker::setOgreShowConfigDialog
virtual void setOgreShowConfigDialog(bool showConfigDialog)
Definition: vpMbEdgeKltMultiTracker.cpp:1878
vpMbKltMultiTracker::setGoodNbRayCastingAttemptsRatio
void setGoodNbRayCastingAttemptsRatio(const double &ratio)
Definition: vpMbKltMultiTracker.cpp:2223
vpMbEdgeMultiTracker::setClipping
virtual void setClipping(const unsigned int &flags)
Definition: vpMbEdgeMultiTracker.cpp:2218
vpMbtPolygon
Implementation of a polygon of the model used by the model-based tracker.
Definition: vpMbtPolygon.h:65
vpMbKltMultiTracker::setThresholdAcceptation
virtual void setThresholdAcceptation(double th)
Definition: vpMbKltMultiTracker.cpp:2861
vpMbKltMultiTracker::initFromPose
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
Definition: vpMbKltMultiTracker.cpp:1290
vpMbKltMultiTracker::setOgreShowConfigDialog
virtual void setOgreShowConfigDialog(bool showConfigDialog)
Definition: vpMbKltMultiTracker.cpp:2408
vpColVector::insert
void insert(unsigned int i, const vpColVector &v)
Definition: vpColVector.cpp:1361
vpMbKltMultiTracker
Model based stereo (or more) tracker using only KLT.
Definition: vpMbKltMultiTracker.h:74
vpMbTracker::m_initialMu
double m_initialMu
Initial Mu for Levenberg Marquardt optimization loop.
Definition: vpMbTracker.h:192
vpMbEdgeKltMultiTracker::getKltMultiNbPolygon
virtual std::map< std::string, unsigned int > getKltMultiNbPolygon() const
Definition: vpMbEdgeKltMultiTracker.cpp:780
vpArray2D::resize
void resize(unsigned int nrows, unsigned int ncols, bool flagNullify=true, bool recopy_=true)
Definition: vpArray2D.h:304
vpTrackingException::initializationError
Definition: vpTrackingException.h:80
vpMbTracker::computeVVSPoseEstimation
virtual void computeVVSPoseEstimation(const bool isoJoIdentity_, 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:2924
vpMbtDistanceKltPoints::polygon
vpMbtPolygon * polygon
Pointer to the polygon that define a face.
Definition: vpMbtDistanceKltPoints.h:105
vpMbEdgeTracker::m_wCylinders
vpColVector m_wCylinders
Definition: vpMbEdgeTracker.h:316
vpMbTracker::displayFeatures
bool displayFeatures
If true, the features are displayed.
Definition: vpMbTracker.h:137
vpMbKltTracker::ctTc0
vpHomogeneousMatrix ctTc0
Definition: vpMbKltTracker.h:242
vpMbKltMultiTracker::reInitModel
virtual void reInitModel(const vpImage< unsigned char > &I, const std::string &cad_name, const vpHomogeneousMatrix &cMo, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbKltMultiTracker.cpp:1759
vpMbEdgeMultiTracker::getMultiNbPolygon
virtual std::map< std::string, unsigned int > getMultiNbPolygon() const
Definition: vpMbEdgeMultiTracker.cpp:1117
vpMbEdgeMultiTracker::setDisplayFeatures
virtual void setDisplayFeatures(bool displayF)
Definition: vpMbEdgeMultiTracker.cpp:2280
vpMbTracker::oJo
vpMatrix oJo
The Degrees of Freedom to estimate.
Definition: vpMbTracker.h:114
vpMbEdgeKltMultiTracker::track
virtual void track(const vpImage< unsigned char > &I)
Definition: vpMbEdgeKltMultiTracker.cpp:2103
vpMbEdgeKltMultiTracker::setLod
virtual void setLod(bool useLod, const std::string &name="")
Definition: vpMbEdgeKltMultiTracker.cpp:1759
vpMbEdgeMultiTracker::setNearClippingDistance
virtual void setNearClippingDistance(const double &dist)
Definition: vpMbEdgeMultiTracker.cpp:2534
vpMbEdgeMultiTracker::setPose
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo)
Definition: vpMbEdgeMultiTracker.cpp:2625
vpColVector::stack
void stack(double d)
Definition: vpColVector.cpp:999
vpMbEdgeKltMultiTracker::setDisplayFeatures
virtual void setDisplayFeatures(bool displayF)
Definition: vpMbEdgeKltMultiTracker.cpp:1687
vpMbEdgeTracker::computeProjectionError
void computeProjectionError(const vpImage< unsigned char > &_I)
Definition: vpMbEdgeTracker.cpp:864
vpPoseVector
Implementation of a pose vector and operations on poses.
Definition: vpPoseVector.h:150
vpMbEdgeKltMultiTracker::setCameraParameters
virtual void setCameraParameters(const vpCameraParameters &camera)
Definition: vpMbEdgeKltMultiTracker.cpp:1531
vpMbEdgeKltMultiTracker::getCameraParameters
virtual void getCameraParameters(vpCameraParameters &camera) const
Definition: vpMbEdgeKltMultiTracker.cpp:641
vpMbEdgeKltMultiTracker::getEdgeFaces
std::map< std::string, vpMbHiddenFaces< vpMbtPolygon > > getEdgeFaces() const
Definition: vpMbEdgeKltMultiTracker.cpp:729
vpMbEdgeTracker::updateMovingEdgeWeights
void updateMovingEdgeWeights()
Definition: vpMbEdgeTracker.cpp:1717
vpMbtPolygon::isVisible
virtual bool isVisible(const vpHomogeneousMatrix &cMo, double alpha, const bool &modulo=false, const vpCameraParameters &cam=vpCameraParameters(), unsigned int width=0, unsigned int height=0)
Definition: vpMbtPolygon.cpp:106
vpMbTracker::computeVVSWeights
virtual void computeVVSWeights(vpRobust &robust, const vpColVector &error, vpColVector &w)
Definition: vpMbTracker.cpp:2987
vpMbEdgeTracker::computeVVSInit
virtual void computeVVSInit()
Definition: vpMbEdgeTracker.cpp:724
vpVelocityTwistMatrix
Definition: vpVelocityTwistMatrix.h:165
vpMbEdgeKltMultiTracker::m_referenceCameraName
std::string m_referenceCameraName
Name of the reference camera.
Definition: vpMbEdgeKltMultiTracker.h:93
vpMbKltMultiTracker::setOptimizationMethod
virtual void setOptimizationMethod(const vpMbtOptimizationMethod &opt)
Definition: vpMbKltMultiTracker.cpp:2462
vpMbEdgeMultiTracker::m_mapOfEdgeTrackers
std::map< std::string, vpMbEdgeTracker * > m_mapOfEdgeTrackers
Map of Model-based edge trackers.
Definition: vpMbEdgeMultiTracker.h:80
vpMbEdgeTracker::computeVVSFirstPhaseFactor
void computeVVSFirstPhaseFactor(const vpImage< unsigned char > &I, unsigned int lvl=0)
Definition: vpMbEdgeTracker.cpp:555
vpHomogeneousMatrix::buildFrom
void buildFrom(const vpTranslationVector &t, const vpRotationMatrix &R)
Definition: vpHomogeneousMatrix.cpp:221
vpExponentialMap::direct
static vpHomogeneousMatrix direct(const vpColVector &v)
Definition: vpExponentialMap.cpp:58
vpMbEdgeMultiTracker::setScanLineVisibilityTest
virtual void setScanLineVisibilityTest(const bool &v)
Definition: vpMbEdgeMultiTracker.cpp:2891
vpMbEdgeKltMultiTracker::setCameraTransformationMatrix
virtual void setCameraTransformationMatrix(const std::string &cameraName, const vpHomogeneousMatrix &cameraTransformationMatrix)
Definition: vpMbEdgeKltMultiTracker.cpp:1603
vpVelocityTwistMatrix::buildFrom
vpVelocityTwistMatrix buildFrom(const vpTranslationVector &t, const vpRotationMatrix &R)
Definition: vpVelocityTwistMatrix.cpp:363
vpMbEdgeKltMultiTracker::getNbPolygon
virtual unsigned int getNbPolygon() const
Definition: vpMbEdgeKltMultiTracker.cpp:755
vpColVector::resize
void resize(unsigned int i, bool flagNullify=true)
Definition: vpColVector.h:309
vpMbEdgeMultiTracker::getFaces
virtual vpMbHiddenFaces< vpMbtPolygon > & getFaces()
Definition: vpMbEdgeMultiTracker.cpp:787
vpMbKltMultiTracker::initClick
virtual void initClick(const vpImage< unsigned char > &I, const std::vector< vpPoint > &points3D_list, const std::string &displayFile="")
Definition: vpMbKltMultiTracker.cpp:948
vpRobust::resize
void resize(unsigned int n_data)
Resize containers for sort methods.
Definition: vpRobust.cpp:127
vpMbTracker::isoJoIdentity
bool isoJoIdentity
Boolean to know if oJo is identity (for fast computation)
Definition: vpMbTracker.h:116
vpMbEdgeTracker::m_errorCylinders
vpColVector m_errorCylinders
Definition: vpMbEdgeTracker.h:319
vpMbTracker::m_maxIter
unsigned int m_maxIter
Maximum number of iterations of the virtual visual servoing stage.
Definition: vpMbTracker.h:188
vpMbKltMultiTracker::setAngleAppear
virtual void setAngleAppear(const double &a)
Definition: vpMbKltMultiTracker.cpp:1939
vpMbEdgeTracker::m_L_edge
vpMatrix m_L_edge
Interaction matrix.
Definition: vpMbEdgeTracker.h:322
vpMbKltTracker::m_robust_klt
vpRobust m_robust_klt
Robust.
Definition: vpMbKltTracker.h:264
vpMbKltTracker::c0Mo
vpHomogeneousMatrix c0Mo
Initial pose.
Definition: vpMbKltTracker.h:228
vpMbEdgeKltMultiTracker::setClipping
virtual void setClipping(const unsigned int &flags)
Definition: vpMbEdgeKltMultiTracker.cpp:1640
vpMbKltMultiTracker::setCameraTransformationMatrix
virtual void setCameraTransformationMatrix(const std::string &cameraName, const vpHomogeneousMatrix &cameraTransformationMatrix)
Definition: vpMbKltMultiTracker.cpp:2080
vpMbEdgeKltMultiTracker::testTracking
virtual void testTracking()
Definition: vpMbEdgeKltMultiTracker.cpp:2091
vpMbEdgeKltMultiTracker::initFromPose
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
Definition: vpMbEdgeKltMultiTracker.cpp:1084
vpMbEdgeKltMultiTracker::m_factorKLT
double m_factorKLT
Factor for KLT trackers.
Definition: vpMbEdgeKltMultiTracker.h:80
vpMbEdgeMultiTracker::reInitModel
virtual void reInitModel(const vpImage< unsigned char > &I, const std::string &cad_name, const vpHomogeneousMatrix &cMo, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbEdgeMultiTracker.cpp:1868
vpMbtDistanceKltCylinder::isTracked
bool isTracked() const
Definition: vpMbtDistanceKltCylinder.h:195
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:2822
vpHomogeneousMatrix::inverse
vpHomogeneousMatrix inverse() const
Definition: vpHomogeneousMatrix.cpp:640
vpImage< unsigned char >
vpMbEdgeMultiTracker::loadConfigFile
virtual void loadConfigFile(const std::string &configFile)
Definition: vpMbEdgeMultiTracker.cpp:1700
vpMbKltMultiTracker::preTracking
virtual void preTracking(std::map< std::string, const vpImage< unsigned char > * > &mapOfImages)
Definition: vpMbKltMultiTracker.cpp:1696
vpMbEdgeKltMultiTracker::reInitModel
virtual void reInitModel(const vpImage< unsigned char > &I, const std::string &cad_name, const vpHomogeneousMatrix &cMo, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbEdgeKltMultiTracker.cpp:1437
vpPoint
Class that defines what is a point.
Definition: vpPoint.h:57
vpColor
Class to define colors available for display functionnalities.
Definition: vpColor.h:118
vpMbEdgeKltMultiTracker::setProjectionErrorComputation
virtual void setProjectionErrorComputation(const bool &flag)
Definition: vpMbEdgeKltMultiTracker.cpp:2046
vpMbEdgeMultiTracker::resetTracker
virtual void resetTracker()
Definition: vpMbEdgeMultiTracker.cpp:1991
vpMbEdgeKltMultiTracker::setThresholdAcceptation
virtual void setThresholdAcceptation(double th)
Definition: vpMbEdgeKltMultiTracker.cpp:2086
vpHomogeneousMatrix
Implementation of an homogeneous matrix and operations on such kind of matrices.
Definition: vpHomogeneousMatrix.h:148
vpMbEdgeKltMultiTracker::setScanLineVisibilityTest
virtual void setScanLineVisibilityTest(const bool &v)
Definition: vpMbEdgeKltMultiTracker.cpp:2075
vpMbEdgeKltMultiTracker::setNearClippingDistance
virtual void setNearClippingDistance(const double &dist)
Definition: vpMbEdgeKltMultiTracker.cpp:1850
vpMbEdgeKltMultiTracker::getCameraNames
virtual std::vector< std::string > getCameraNames() const
Definition: vpMbEdgeKltMultiTracker.cpp:631
vpMbKltTracker::m_nbInfos
unsigned int m_nbInfos
Definition: vpMbKltTracker.h:252
vpMbKltMultiTracker::getMultiNbPolygon
virtual std::map< std::string, unsigned int > getMultiNbPolygon() const
Definition: vpMbKltMultiTracker.cpp:869
vpMbKltMultiTracker::loadConfigFile
virtual void loadConfigFile(const std::string &configFile)
Definition: vpMbKltMultiTracker.cpp:1552
vpMbEdgeKltMultiTracker::initCylinder
virtual void initCylinder(const vpPoint &, const vpPoint &, const double, const int, const std::string &name="")
Definition: vpMbEdgeKltMultiTracker.cpp:1046
vpMbKltMultiTracker::setNearClippingDistance
virtual void setNearClippingDistance(const double &dist)
Definition: vpMbKltMultiTracker.cpp:2388
vpMbHiddenFaces::computeScanLineRender
void computeScanLineRender(const vpCameraParameters &cam, const unsigned int &w, const unsigned int &h)
Definition: vpMbHiddenFaces.h:463
vpMbKltMultiTracker::setClipping
virtual void setClipping(const unsigned int &flags)
Definition: vpMbKltMultiTracker.cpp:2124
vpMbKltMultiTracker::m_mapOfKltTrackers
std::map< std::string, vpMbKltTracker * > m_mapOfKltTrackers
Map of Model-based klt trackers.
Definition: vpMbKltMultiTracker.h:82
vpException
error that can be emited by ViSP classes.
Definition: vpException.h:70
vpMbKltMultiTracker::setCovarianceComputation
virtual void setCovarianceComputation(const bool &flag)
Definition: vpMbKltMultiTracker.cpp:2157
vpMbEdgeKltMultiTracker::setOgreVisibilityTest
virtual void setOgreVisibilityTest(const bool &v)
Definition: vpMbEdgeKltMultiTracker.cpp:1892
vpMbEdgeTracker::computeVVSInteractionMatrixAndResidu
virtual void computeVVSInteractionMatrixAndResidu()
Definition: vpMbEdgeTracker.cpp:767
vpMbTracker::computeProjError
bool computeProjError
Definition: vpMbTracker.h:132
vpMbKltMultiTracker::setCameraParameters
virtual void setCameraParameters(const vpCameraParameters &camera)
Definition: vpMbKltMultiTracker.cpp:1973
vpMbTracker::m_I
vpImage< unsigned char > m_I
Grayscale image buffer, used when passing color images.
Definition: vpMbTracker.h:222
vpMbEdgeMultiTracker::getCameraParameters
virtual void getCameraParameters(vpCameraParameters &camera) const
Definition: vpMbEdgeMultiTracker.cpp:698
vpMbEdgeMultiTracker::getCameraNames
virtual std::vector< std::string > getCameraNames() const
Definition: vpMbEdgeMultiTracker.cpp:681
vpMbEdgeKltMultiTracker::resetTracker
virtual void resetTracker()
Definition: vpMbEdgeKltMultiTracker.cpp:1490
vpMbEdgeTracker::m_wLines
vpColVector m_wLines
Definition: vpMbEdgeTracker.h:315
vpMbKltMultiTracker::postTracking
virtual void postTracking(std::map< std::string, const vpImage< unsigned char > * > &mapOfImages)
Definition: vpMbKltMultiTracker.cpp:1714
vpArray2D::getRows
unsigned int getRows() const
Definition: vpArray2D.h:288