Visual Servoing Platform  version 3.6.0 under development (2023-09-25)
vpMbGenericTracker.h
1 /****************************************************************************
2  *
3  * ViSP, open source Visual Servoing Platform software.
4  * Copyright (C) 2005 - 2023 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 https://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  * Generic model-based tracker.
33  *
34 *****************************************************************************/
40 #ifndef _vpMbGenericTracker_h_
41 #define _vpMbGenericTracker_h_
42 
43 #include <visp3/mbt/vpMbDepthDenseTracker.h>
44 #include <visp3/mbt/vpMbDepthNormalTracker.h>
45 #include <visp3/mbt/vpMbEdgeTracker.h>
46 #include <visp3/mbt/vpMbKltTracker.h>
47 
48 #ifdef VISP_HAVE_NLOHMANN_JSON
49 #include <nlohmann/json_fwd.hpp>
50 #include <visp3/core/vpJsonParsing.h>
51 #endif
52 
199 class VISP_EXPORT vpMbGenericTracker : public vpMbTracker
200 {
201 public:
202  enum vpTrackerType
203  {
204  EDGE_TRACKER = 1 << 0,
205 #if defined(VISP_HAVE_MODULE_KLT) && (defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO))
206  KLT_TRACKER = 1 << 1,
207 #endif
208  DEPTH_NORMAL_TRACKER = 1 << 2,
209  DEPTH_DENSE_TRACKER = 1 << 3
210  };
211 
212  vpMbGenericTracker();
213  vpMbGenericTracker(unsigned int nbCameras, int trackerType = EDGE_TRACKER);
214  explicit vpMbGenericTracker(const std::vector<int> &trackerTypes);
215  vpMbGenericTracker(const std::vector<std::string> &cameraNames, const std::vector<int> &trackerTypes);
216 
217  virtual ~vpMbGenericTracker();
218 
219  virtual double computeCurrentProjectionError(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &_cMo,
220  const vpCameraParameters &_cam);
221  virtual double computeCurrentProjectionError(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &_cMo,
222  const vpCameraParameters &_cam);
223 
224  virtual void display(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
225  const vpColor &col, unsigned int thickness = 1, bool displayFullModel = false);
226  virtual void display(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
227  const vpColor &col, unsigned int thickness = 1, bool displayFullModel = false);
228 
229  virtual void display(const vpImage<unsigned char> &I1, const vpImage<unsigned char> &I2,
230  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo, const vpCameraParameters &cam1,
231  const vpCameraParameters &cam2, const vpColor &color, unsigned int thickness = 1,
232  bool displayFullModel = false);
233  virtual void display(const vpImage<vpRGBa> &I1, const vpImage<vpRGBa> &I2, const vpHomogeneousMatrix &c1Mo,
234  const vpHomogeneousMatrix &c2Mo, const vpCameraParameters &cam1, const vpCameraParameters &cam2,
235  const vpColor &color, unsigned int thickness = 1, bool displayFullModel = false);
236 
237  virtual void display(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
238  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses,
239  const std::map<std::string, vpCameraParameters> &mapOfCameraParameters, const vpColor &col,
240  unsigned int thickness = 1, bool displayFullModel = false);
241  virtual void display(const std::map<std::string, const vpImage<vpRGBa> *> &mapOfImages,
242  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses,
243  const std::map<std::string, vpCameraParameters> &mapOfCameraParameters, const vpColor &col,
244  unsigned int thickness = 1, bool displayFullModel = false);
245 
246  virtual std::vector<std::string> getCameraNames() const;
247 
248  using vpMbTracker::getCameraParameters;
249  virtual void getCameraParameters(vpCameraParameters &camera) const;
250  virtual void getCameraParameters(vpCameraParameters &cam1, vpCameraParameters &cam2) const;
251  virtual void getCameraParameters(std::map<std::string, vpCameraParameters> &mapOfCameraParameters) const;
252 
253  virtual std::map<std::string, int> getCameraTrackerTypes() const;
254 
255  using vpMbTracker::getClipping;
256  virtual void getClipping(unsigned int &clippingFlag1, unsigned int &clippingFlag2) const;
257  virtual void getClipping(std::map<std::string, unsigned int> &mapOfClippingFlags) const;
258 
259  virtual inline vpColVector getError() const { return m_error; }
260 
261  virtual vpMbHiddenFaces<vpMbtPolygon> &getFaces();
262  virtual vpMbHiddenFaces<vpMbtPolygon> &getFaces(const std::string &cameraName);
263 
264 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
265  virtual std::list<vpMbtDistanceCircle *> &getFeaturesCircle();
266  virtual std::list<vpMbtDistanceKltCylinder *> &getFeaturesKltCylinder();
267  virtual std::list<vpMbtDistanceKltPoints *> &getFeaturesKlt();
268 #endif
269 
270  virtual std::vector<std::vector<double> > getFeaturesForDisplay();
271  virtual void getFeaturesForDisplay(std::map<std::string, std::vector<std::vector<double> > > &mapOfFeatures);
272 
273  virtual double getGoodMovingEdgesRatioThreshold() const;
274 
275 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
276  virtual std::vector<vpImagePoint> getKltImagePoints() const;
277  virtual std::map<int, vpImagePoint> getKltImagePointsWithId() const;
278 
279  virtual unsigned int getKltMaskBorder() const;
280  virtual int getKltNbPoints() const;
281 
282  virtual vpKltOpencv getKltOpencv() const;
283  virtual void getKltOpencv(vpKltOpencv &klt1, vpKltOpencv &klt2) const;
284  virtual void getKltOpencv(std::map<std::string, vpKltOpencv> &mapOfKlts) const;
285 
286 #if defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
287  virtual std::vector<cv::Point2f> getKltPoints() const;
288 #endif
289 
290  virtual double getKltThresholdAcceptation() const;
291 #endif
292 
293  virtual void getLcircle(std::list<vpMbtDistanceCircle *> &circlesList, unsigned int level = 0) const;
294  virtual void getLcircle(const std::string &cameraName, std::list<vpMbtDistanceCircle *> &circlesList,
295  unsigned int level = 0) const;
296  virtual void getLcylinder(std::list<vpMbtDistanceCylinder *> &cylindersList, unsigned int level = 0) const;
297  virtual void getLcylinder(const std::string &cameraName, std::list<vpMbtDistanceCylinder *> &cylindersList,
298  unsigned int level = 0) const;
299  virtual void getLline(std::list<vpMbtDistanceLine *> &linesList, unsigned int level = 0) const;
300  virtual void getLline(const std::string &cameraName, std::list<vpMbtDistanceLine *> &linesList,
301  unsigned int level = 0) const;
302 
303  virtual std::vector<std::vector<double> > getModelForDisplay(unsigned int width, unsigned int height,
304  const vpHomogeneousMatrix &cMo,
305  const vpCameraParameters &cam,
306  bool displayFullModel = false);
307  virtual void getModelForDisplay(std::map<std::string, std::vector<std::vector<double> > > &mapOfModels,
308  const std::map<std::string, unsigned int> &mapOfwidths,
309  const std::map<std::string, unsigned int> &mapOfheights,
310  const std::map<std::string, vpHomogeneousMatrix> &mapOfcMos,
311  const std::map<std::string, vpCameraParameters> &mapOfCams,
312  bool displayFullModel = false);
313 
314  virtual vpMe getMovingEdge() const;
315  virtual void getMovingEdge(vpMe &me1, vpMe &me2) const;
316  virtual void getMovingEdge(std::map<std::string, vpMe> &mapOfMovingEdges) const;
317 
321  virtual inline unsigned int getNbFeaturesDepthDense() const { return m_nb_feat_depthDense; }
325  virtual inline unsigned int getNbFeaturesDepthNormal() const { return m_nb_feat_depthNormal; }
331  virtual inline unsigned int getNbFeaturesEdge() const { return m_nb_feat_edge; }
335  virtual inline unsigned int getNbFeaturesKlt() const { return m_nb_feat_klt; }
336 
337  virtual unsigned int getNbPoints(unsigned int level = 0) const;
338  virtual void getNbPoints(std::map<std::string, unsigned int> &mapOfNbPoints, unsigned int level = 0) const;
339 
340  virtual unsigned int getNbPolygon() const;
341  virtual void getNbPolygon(std::map<std::string, unsigned int> &mapOfNbPolygons) const;
342 
343  virtual vpMbtPolygon *getPolygon(unsigned int index);
344  virtual vpMbtPolygon *getPolygon(const std::string &cameraName, unsigned int index);
345 
346  virtual std::pair<std::vector<vpPolygon>, std::vector<std::vector<vpPoint> > >
347  getPolygonFaces(bool orderPolygons = true, bool useVisibility = true, bool clipPolygon = false);
348  virtual void getPolygonFaces(std::map<std::string, std::vector<vpPolygon> > &mapOfPolygons,
349  std::map<std::string, std::vector<std::vector<vpPoint> > > &mapOfPoints,
350  bool orderPolygons = true, bool useVisibility = true, bool clipPolygon = false);
351 
352  using vpMbTracker::getPose;
353  virtual void getPose(vpHomogeneousMatrix &cMo) const;
354  virtual void getPose(vpHomogeneousMatrix &c1Mo, vpHomogeneousMatrix &c2Mo) const;
355  virtual void getPose(std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses) const;
356 
357  virtual std::string getReferenceCameraName() const;
358 
359  virtual inline vpColVector getRobustWeights() const { return m_w; }
360 
361  virtual int getTrackerType() const;
362 
363  virtual void init(const vpImage<unsigned char> &I);
364 
365 #ifdef VISP_HAVE_MODULE_GUI
366  using vpMbTracker::initClick;
367  virtual void initClick(const vpImage<unsigned char> &I1, const vpImage<unsigned char> &I2,
368  const std::string &initFile1, const std::string &initFile2, bool displayHelp = false,
369  const vpHomogeneousMatrix &T1 = vpHomogeneousMatrix(),
370  const vpHomogeneousMatrix &T2 = vpHomogeneousMatrix());
371  virtual void initClick(const vpImage<vpRGBa> &I_color1, const vpImage<vpRGBa> &I_color2, const std::string &initFile1,
372  const std::string &initFile2, bool displayHelp = false,
373  const vpHomogeneousMatrix &T1 = vpHomogeneousMatrix(),
374  const vpHomogeneousMatrix &T2 = vpHomogeneousMatrix());
375 
376  virtual void
377  initClick(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
378  const std::map<std::string, std::string> &mapOfInitFiles, bool displayHelp = false,
379  const std::map<std::string, vpHomogeneousMatrix> &mapOfT = std::map<std::string, vpHomogeneousMatrix>());
380  virtual void
381  initClick(const std::map<std::string, const vpImage<vpRGBa> *> &mapOfImages,
382  const std::map<std::string, std::string> &mapOfInitFiles, bool displayHelp = false,
383  const std::map<std::string, vpHomogeneousMatrix> &mapOfT = std::map<std::string, vpHomogeneousMatrix>());
384 #endif
385 
386  using vpMbTracker::initFromPoints;
387  virtual void initFromPoints(const vpImage<unsigned char> &I1, const vpImage<unsigned char> &I2,
388  const std::string &initFile1, const std::string &initFile2);
389  virtual void initFromPoints(const vpImage<vpRGBa> &I_color1, const vpImage<vpRGBa> &I_color2,
390  const std::string &initFile1, const std::string &initFile2);
391 
392  virtual void initFromPoints(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
393  const std::map<std::string, std::string> &mapOfInitPoints);
394  virtual void initFromPoints(const std::map<std::string, const vpImage<vpRGBa> *> &mapOfColorImages,
395  const std::map<std::string, std::string> &mapOfInitPoints);
396 
397  using vpMbTracker::initFromPose;
398  virtual void initFromPose(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo);
399  virtual void initFromPose(const vpImage<unsigned char> &I1, const vpImage<unsigned char> &I2,
400  const std::string &initFile1, const std::string &initFile2);
401  virtual void initFromPose(const vpImage<vpRGBa> &I_color1, const vpImage<vpRGBa> &I_color2,
402  const std::string &initFile1, const std::string &initFile2);
403 
404  virtual void initFromPose(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
405  const std::map<std::string, std::string> &mapOfInitPoses);
406  virtual void initFromPose(const std::map<std::string, const vpImage<vpRGBa> *> &mapOfColorImages,
407  const std::map<std::string, std::string> &mapOfInitPoses);
408 
409  virtual void initFromPose(const vpImage<unsigned char> &I1, const vpImage<unsigned char> &I2,
410  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo);
411  virtual void initFromPose(const vpImage<vpRGBa> &I_color1, const vpImage<vpRGBa> &I_color2,
412  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo);
413 
414  virtual void initFromPose(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
415  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses);
416  virtual void initFromPose(const std::map<std::string, const vpImage<vpRGBa> *> &mapOfColorImages,
417  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses);
418 
419  virtual void loadConfigFile(const std::string &configFile, bool verbose = true);
420  virtual void loadConfigFile(const std::string &configFile1, const std::string &configFile2, bool verbose = true);
421  virtual void loadConfigFile(const std::map<std::string, std::string> &mapOfConfigFiles, bool verbose = true);
422 
423 #ifdef VISP_HAVE_NLOHMANN_JSON
424  virtual void saveConfigFile(const std::string &settingsFile) const;
425 #endif
426 
427  virtual void loadModel(const std::string &modelFile, bool verbose = false,
428  const vpHomogeneousMatrix &T = vpHomogeneousMatrix());
429  virtual void loadModel(const std::string &modelFile1, const std::string &modelFile2, bool verbose = false,
430  const vpHomogeneousMatrix &T1 = vpHomogeneousMatrix(),
431  const vpHomogeneousMatrix &T2 = vpHomogeneousMatrix());
432 
433  virtual void
434  loadModel(const std::map<std::string, std::string> &mapOfModelFiles, bool verbose = false,
435  const std::map<std::string, vpHomogeneousMatrix> &mapOfT = std::map<std::string, vpHomogeneousMatrix>());
436 
437  virtual void reInitModel(const vpImage<unsigned char> &I, const std::string &cad_name, const vpHomogeneousMatrix &cMo,
438  bool verbose = false, const vpHomogeneousMatrix &T = vpHomogeneousMatrix());
439  virtual void reInitModel(const vpImage<vpRGBa> &I_color, const std::string &cad_name, const vpHomogeneousMatrix &cMo,
440  bool verbose = false, const vpHomogeneousMatrix &T = vpHomogeneousMatrix());
441 
442  virtual void reInitModel(const vpImage<unsigned char> &I1, const vpImage<unsigned char> &I2,
443  const std::string &cad_name1, const std::string &cad_name2, const vpHomogeneousMatrix &c1Mo,
444  const vpHomogeneousMatrix &c2Mo, bool verbose = false,
445  const vpHomogeneousMatrix &T1 = vpHomogeneousMatrix(),
446  const vpHomogeneousMatrix &T2 = vpHomogeneousMatrix());
447  virtual void reInitModel(const vpImage<vpRGBa> &I_color1, const vpImage<vpRGBa> &I_color2,
448  const std::string &cad_name1, const std::string &cad_name2, const vpHomogeneousMatrix &c1Mo,
449  const vpHomogeneousMatrix &c2Mo, bool verbose = false,
450  const vpHomogeneousMatrix &T1 = vpHomogeneousMatrix(),
451  const vpHomogeneousMatrix &T2 = vpHomogeneousMatrix());
452 
453  virtual void
454  reInitModel(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
455  const std::map<std::string, std::string> &mapOfModelFiles,
456  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses, bool verbose = false,
457  const std::map<std::string, vpHomogeneousMatrix> &mapOfT = std::map<std::string, vpHomogeneousMatrix>());
458  virtual void
459  reInitModel(const std::map<std::string, const vpImage<vpRGBa> *> &mapOfColorImages,
460  const std::map<std::string, std::string> &mapOfModelFiles,
461  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses, bool verbose = false,
462  const std::map<std::string, vpHomogeneousMatrix> &mapOfT = std::map<std::string, vpHomogeneousMatrix>());
463 
464  virtual void resetTracker();
465 
466  virtual void setAngleAppear(const double &a);
467  virtual void setAngleAppear(const double &a1, const double &a2);
468  virtual void setAngleAppear(const std::map<std::string, double> &mapOfAngles);
469 
470  virtual void setAngleDisappear(const double &a);
471  virtual void setAngleDisappear(const double &a1, const double &a2);
472  virtual void setAngleDisappear(const std::map<std::string, double> &mapOfAngles);
473 
474  virtual void setCameraParameters(const vpCameraParameters &camera);
475  virtual void setCameraParameters(const vpCameraParameters &camera1, const vpCameraParameters &camera2);
476  virtual void setCameraParameters(const std::map<std::string, vpCameraParameters> &mapOfCameraParameters);
477 
478  virtual void setCameraTransformationMatrix(const std::string &cameraName,
479  const vpHomogeneousMatrix &cameraTransformationMatrix);
480  virtual void
481  setCameraTransformationMatrix(const std::map<std::string, vpHomogeneousMatrix> &mapOfTransformationMatrix);
482 
483  virtual void setClipping(const unsigned int &flags);
484  virtual void setClipping(const unsigned int &flags1, const unsigned int &flags2);
485  virtual void setClipping(const std::map<std::string, unsigned int> &mapOfClippingFlags);
486 
487  virtual void setDepthDenseFilteringMaxDistance(double maxDistance);
488  virtual void setDepthDenseFilteringMethod(int method);
489  virtual void setDepthDenseFilteringMinDistance(double minDistance);
490  virtual void setDepthDenseFilteringOccupancyRatio(double occupancyRatio);
491  virtual void setDepthDenseSamplingStep(unsigned int stepX, unsigned int stepY);
492 
493  virtual void setDepthNormalFaceCentroidMethod(const vpMbtFaceDepthNormal::vpFaceCentroidType &method);
494  virtual void setDepthNormalFeatureEstimationMethod(const vpMbtFaceDepthNormal::vpFeatureEstimationType &method);
495  virtual void setDepthNormalPclPlaneEstimationMethod(int method);
496  virtual void setDepthNormalPclPlaneEstimationRansacMaxIter(int maxIter);
497  virtual void setDepthNormalPclPlaneEstimationRansacThreshold(double threshold);
498  virtual void setDepthNormalSamplingStep(unsigned int stepX, unsigned int stepY);
499 
500  virtual void setDisplayFeatures(bool displayF);
501 
502  virtual void setFarClippingDistance(const double &dist);
503  virtual void setFarClippingDistance(const double &dist1, const double &dist2);
504  virtual void setFarClippingDistance(const std::map<std::string, double> &mapOfClippingDists);
505 
506  virtual void setFeatureFactors(const std::map<vpTrackerType, double> &mapOfFeatureFactors);
507 
508  virtual void setGoodMovingEdgesRatioThreshold(double threshold);
509 
510 #ifdef VISP_HAVE_OGRE
511  virtual void setGoodNbRayCastingAttemptsRatio(const double &ratio);
512  virtual void setNbRayCastingAttemptsForVisibility(const unsigned int &attempts);
513 #endif
514 
515 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
516  virtual void setKltMaskBorder(const unsigned int &e);
517  virtual void setKltMaskBorder(const unsigned int &e1, const unsigned int &e2);
518  virtual void setKltMaskBorder(const std::map<std::string, unsigned int> &mapOfErosions);
519 
520  virtual void setKltOpencv(const vpKltOpencv &t);
521  virtual void setKltOpencv(const vpKltOpencv &t1, const vpKltOpencv &t2);
522  virtual void setKltOpencv(const std::map<std::string, vpKltOpencv> &mapOfKlts);
523 
524  virtual void setKltThresholdAcceptation(double th);
525 #endif
526 
527  virtual void setLod(bool useLod, const std::string &name = "");
528 
529  virtual void setMask(const vpImage<bool> &mask);
530 
531  virtual void setMinLineLengthThresh(double minLineLengthThresh, const std::string &name = "");
532  virtual void setMinPolygonAreaThresh(double minPolygonAreaThresh, const std::string &name = "");
533 
534  virtual void setMovingEdge(const vpMe &me);
535  virtual void setMovingEdge(const vpMe &me1, const vpMe &me2);
536  virtual void setMovingEdge(const std::map<std::string, vpMe> &mapOfMe);
537 
538  virtual void setNearClippingDistance(const double &dist);
539  virtual void setNearClippingDistance(const double &dist1, const double &dist2);
540  virtual void setNearClippingDistance(const std::map<std::string, double> &mapOfDists);
541 
542  virtual void setOgreShowConfigDialog(bool showConfigDialog);
543  virtual void setOgreVisibilityTest(const bool &v);
544 
545  virtual void setOptimizationMethod(const vpMbtOptimizationMethod &opt);
546 
547  virtual void setPose(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cdMo);
548  virtual void setPose(const vpImage<vpRGBa> &I_color, const vpHomogeneousMatrix &cdMo);
549 
550  virtual void setPose(const vpImage<unsigned char> &I1, const vpImage<unsigned char> &I2,
551  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo);
552  virtual void setPose(const vpImage<vpRGBa> &I_color1, const vpImage<vpRGBa> &I_color2,
553  const vpHomogeneousMatrix &c1Mo, const vpHomogeneousMatrix &c2Mo);
554 
555  virtual void setPose(const std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
556  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses);
557  virtual void setPose(const std::map<std::string, const vpImage<vpRGBa> *> &mapOfColorImages,
558  const std::map<std::string, vpHomogeneousMatrix> &mapOfCameraPoses);
559 
560  virtual void setProjectionErrorComputation(const bool &flag);
561 
562  virtual void setProjectionErrorDisplay(bool display);
563  virtual void setProjectionErrorDisplayArrowLength(unsigned int length);
564  virtual void setProjectionErrorDisplayArrowThickness(unsigned int thickness);
565 
566  virtual void setReferenceCameraName(const std::string &referenceCameraName);
567 
568  virtual void setScanLineVisibilityTest(const bool &v);
569 
570  virtual void setTrackerType(int type);
571  virtual void setTrackerType(const std::map<std::string, int> &mapOfTrackerTypes);
572 
573  virtual void setUseDepthDenseTracking(const std::string &name, const bool &useDepthDenseTracking);
574  virtual void setUseDepthNormalTracking(const std::string &name, const bool &useDepthNormalTracking);
575  virtual void setUseEdgeTracking(const std::string &name, const bool &useEdgeTracking);
576 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
577  virtual void setUseKltTracking(const std::string &name, const bool &useKltTracking);
578 #endif
579 
580  virtual void testTracking();
581 
582  virtual void track(const vpImage<unsigned char> &I);
583  virtual void track(const vpImage<vpRGBa> &I_color);
584 
585  virtual void track(const vpImage<unsigned char> &I1, const vpImage<unsigned char> &I2);
586  virtual void track(const vpImage<vpRGBa> &I_color1, const vpImage<vpRGBa> &I_color2);
587 
588  virtual void track(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages);
589  virtual void track(std::map<std::string, const vpImage<vpRGBa> *> &mapOfColorImages);
590 
591 #ifdef VISP_HAVE_PCL
592  virtual void track(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
593  std::map<std::string, pcl::PointCloud<pcl::PointXYZ>::ConstPtr> &mapOfPointClouds);
594  virtual void track(std::map<std::string, const vpImage<vpRGBa> *> &mapOfColorImages,
595  std::map<std::string, pcl::PointCloud<pcl::PointXYZ>::ConstPtr> &mapOfPointClouds);
596 #endif
597 
598  virtual void track(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
599  std::map<std::string, const std::vector<vpColVector> *> &mapOfPointClouds,
600  std::map<std::string, unsigned int> &mapOfPointCloudWidths,
601  std::map<std::string, unsigned int> &mapOfPointCloudHeights);
602  virtual void track(std::map<std::string, const vpImage<vpRGBa> *> &mapOfColorImages,
603  std::map<std::string, const std::vector<vpColVector> *> &mapOfPointClouds,
604  std::map<std::string, unsigned int> &mapOfPointCloudWidths,
605  std::map<std::string, unsigned int> &mapOfPointCloudHeights);
606 
607 protected:
608  virtual void computeProjectionError();
609 
610  virtual void computeVVS(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages);
611 
612  virtual void computeVVSInit();
613  virtual void computeVVSInit(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages);
614  virtual void computeVVSInteractionMatrixAndResidu();
615  virtual void computeVVSInteractionMatrixAndResidu(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
616  std::map<std::string, vpVelocityTwistMatrix> &mapOfVelocityTwist);
617  using vpMbTracker::computeVVSWeights;
618  virtual void computeVVSWeights();
619 
620  virtual void initCircle(const vpPoint &p1, const vpPoint &p2, const vpPoint &p3, double radius, int idFace = 0,
621  const std::string &name = "");
622 
623  virtual void initCylinder(const vpPoint &p1, const vpPoint &p2, double radius, int idFace = 0,
624  const std::string &name = "");
625 
626  virtual void initFaceFromCorners(vpMbtPolygon &polygon);
627 
628  virtual void initFaceFromLines(vpMbtPolygon &polygon);
629 
630  virtual void loadConfigFileXML(const std::string &configFile, bool verbose = true);
631 #ifdef VISP_HAVE_NLOHMANN_JSON
632  virtual void loadConfigFileJSON(const std::string &configFile, bool verbose = true);
633 #endif
634 
635 #ifdef VISP_HAVE_PCL
636  virtual void preTracking(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
637  std::map<std::string, pcl::PointCloud<pcl::PointXYZ>::ConstPtr> &mapOfPointClouds);
638 #endif
639  virtual void preTracking(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
640  std::map<std::string, const std::vector<vpColVector> *> &mapOfPointClouds,
641  std::map<std::string, unsigned int> &mapOfPointCloudWidths,
642  std::map<std::string, unsigned int> &mapOfPointCloudHeights);
643 
644 private:
645  class TrackerWrapper : public vpMbEdgeTracker,
646 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
647  public vpMbKltTracker,
648 #endif
649  public vpMbDepthNormalTracker,
650  public vpMbDepthDenseTracker
651  {
652  friend class vpMbGenericTracker;
653 #ifdef VISP_HAVE_NLOHMANN_JSON
654  friend void to_json(nlohmann::json &j, const TrackerWrapper &t);
655  friend void from_json(const nlohmann::json &j, TrackerWrapper &t);
656 #endif
657 
658  public:
660  vpColVector m_error;
662  vpMatrix m_L;
664  int m_trackerType;
666  vpColVector m_w;
668  vpColVector m_weightedError;
669 
670  TrackerWrapper();
671  explicit TrackerWrapper(int trackerType);
672 
673  virtual ~TrackerWrapper();
674 
675 
676  virtual inline vpColVector getError() const { return m_error; }
677 
678  virtual inline vpColVector getRobustWeights() const { return m_w; }
679 
680  virtual inline int getTrackerType() const { return m_trackerType; }
681 
682  virtual void display(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
683  const vpColor &col, unsigned int thickness = 1, bool displayFullModel = false);
684  virtual void display(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
685  const vpColor &col, unsigned int thickness = 1, bool displayFullModel = false);
686 
687  virtual std::vector<std::vector<double> > getFeaturesForDisplay();
688 
689  virtual std::vector<std::vector<double> > getModelForDisplay(unsigned int width, unsigned int height,
690  const vpHomogeneousMatrix &cMo,
691  const vpCameraParameters &cam,
692  bool displayFullModel = false);
693 
694  virtual void init(const vpImage<unsigned char> &I);
695 
696  virtual void loadConfigFile(const std::string &configFile, bool verbose = true);
697 
698  virtual void reInitModel(const vpImage<unsigned char> &I, const std::string &cad_name,
699  const vpHomogeneousMatrix &cMo, bool verbose = false,
700  const vpHomogeneousMatrix &T = vpHomogeneousMatrix());
701  virtual void reInitModel(const vpImage<vpRGBa> &I_color, const std::string &cad_name,
702  const vpHomogeneousMatrix &cMo, bool verbose = false,
703  const vpHomogeneousMatrix &T = vpHomogeneousMatrix());
704 
705  virtual void resetTracker();
706 
707  virtual void setCameraParameters(const vpCameraParameters &camera);
708 
709  virtual void setClipping(const unsigned int &flags);
710 
711  virtual void setFarClippingDistance(const double &dist);
712 
713  virtual void setNearClippingDistance(const double &dist);
714 
715  virtual void setOgreVisibilityTest(const bool &v);
716 
717  virtual void setPose(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cdMo);
718  virtual void setPose(const vpImage<vpRGBa> &I_color, const vpHomogeneousMatrix &cdMo);
719 
720  virtual void setProjectionErrorComputation(const bool &flag);
721 
722  virtual void setScanLineVisibilityTest(const bool &v);
723 
724  virtual void setTrackerType(int type);
725 
726  virtual void testTracking();
727 
728  virtual void track(const vpImage<unsigned char> &I);
729  virtual void track(const vpImage<vpRGBa> &I_color);
730 #ifdef VISP_HAVE_PCL
731  // Fix error: using declaration ‘using vpMbDepthDenseTracker::setPose’ conflicts with a previous
732  // using declaration that occurs with g++ 4.6.3 on Ubuntu 12.04
733 #if !((__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
734  using vpMbDepthNormalTracker::track;
735 #endif
736  using vpMbDepthDenseTracker::track;
737  using vpMbEdgeTracker::track;
738  virtual void track(const vpImage<unsigned char> *const ptr_I,
739  const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &point_cloud);
740 #endif
741 
742  protected:
743  virtual void computeVVS(const vpImage<unsigned char> *const ptr_I);
744  virtual void computeVVSInit();
745  virtual void computeVVSInit(const vpImage<unsigned char> *const ptr_I);
746  virtual void computeVVSInteractionMatrixAndResidu();
747  using vpMbEdgeTracker::computeVVSInteractionMatrixAndResidu;
748  virtual void computeVVSInteractionMatrixAndResidu(const vpImage<unsigned char> *const ptr_I);
749  using vpMbTracker::computeVVSWeights;
750  virtual void computeVVSWeights();
751 
752  virtual void initCircle(const vpPoint &p1, const vpPoint &p2, const vpPoint &p3, double radius, int idFace = 0,
753  const std::string &name = "");
754 
755  virtual void initCylinder(const vpPoint &p1, const vpPoint &p2, double radius, int idFace = 0,
756  const std::string &name = "");
757 
758  virtual void initFaceFromCorners(vpMbtPolygon &polygon);
759  virtual void initFaceFromLines(vpMbtPolygon &polygon);
760 
761  virtual void initMbtTracking(const vpImage<unsigned char> *const ptr_I);
762 
763 #ifdef VISP_HAVE_PCL
764  virtual void postTracking(const vpImage<unsigned char> *const ptr_I,
765  const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &point_cloud);
766  virtual void preTracking(const vpImage<unsigned char> *const ptr_I,
767  const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &point_cloud);
768 #endif
769  virtual void postTracking(const vpImage<unsigned char> *const ptr_I = NULL, const unsigned int pointcloud_width = 0,
770  const unsigned int pointcloud_height = 0);
771  virtual void preTracking(const vpImage<unsigned char> *const ptr_I = NULL,
772  const std::vector<vpColVector> *const point_cloud = NULL,
773  const unsigned int pointcloud_width = 0, const unsigned int pointcloud_height = 0);
774 
775  virtual void reInitModel(const vpImage<unsigned char> *const I, const vpImage<vpRGBa> *const I_color,
776  const std::string &cad_name, const vpHomogeneousMatrix &cMo, bool verbose = false,
777  const vpHomogeneousMatrix &T = vpHomogeneousMatrix());
778 
779 #ifdef VISP_HAVE_PCL
780  // Fix error: using declaration ‘using vpMbDepthDenseTracker::track’ conflicts with a previous
781  // using declaration that occurs with g++ 4.6.3 on Ubuntu 12.04
782 #if !((__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
783  using vpMbDepthNormalTracker::setPose;
784 #endif
785  using vpMbDepthDenseTracker::setPose;
786 #endif
787  virtual void setPose(const vpImage<unsigned char> *const I, const vpImage<vpRGBa> *const I_color,
788  const vpHomogeneousMatrix &cdMo);
789  };
790 #ifdef VISP_HAVE_NLOHMANN_JSON
791  friend void to_json(nlohmann::json &j, const TrackerWrapper &t);
792  friend void from_json(const nlohmann::json &j, TrackerWrapper &t);
793 #endif
794 
795 protected:
797  vpColVector m_error;
799  vpMatrix m_L;
802  std::map<std::string, vpHomogeneousMatrix> m_mapOfCameraTransformationMatrix;
804  std::map<vpTrackerType, double> m_mapOfFeatureFactors;
807  std::map<std::string, TrackerWrapper *> m_mapOfTrackers;
810  double m_percentageGdPt;
812  std::string m_referenceCameraName;
815  double m_thresholdOutlier;
817  vpColVector m_w;
819  vpColVector m_weightedError;
820 
822  unsigned int m_nb_feat_edge;
824  unsigned int m_nb_feat_klt;
826  unsigned int m_nb_feat_depthNormal;
828  unsigned int m_nb_feat_depthDense;
829 };
830 
831 #ifdef VISP_HAVE_NLOHMANN_JSON
832 
833 #define MBT_JSON_SETTINGS_VERSION "1.0"
834 
835 // Serialize tracker type enumeration
836 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
837 NLOHMANN_JSON_SERIALIZE_ENUM(vpMbGenericTracker::vpTrackerType, {
838  {vpMbGenericTracker::EDGE_TRACKER, "edge"},
839  {vpMbGenericTracker::KLT_TRACKER, "klt"},
840  {vpMbGenericTracker::DEPTH_DENSE_TRACKER, "depthDense"},
841  {vpMbGenericTracker::DEPTH_NORMAL_TRACKER, "depthNormal"}
842  });
843 #else
844 NLOHMANN_JSON_SERIALIZE_ENUM(vpMbGenericTracker::vpTrackerType, {
845  {vpMbGenericTracker::EDGE_TRACKER, "edge"},
846  {vpMbGenericTracker::DEPTH_DENSE_TRACKER, "depthDense"},
847  {vpMbGenericTracker::DEPTH_NORMAL_TRACKER, "depthNormal"}
848  });
849 #endif
850 
857 inline void to_json(nlohmann::json &j, const vpMbGenericTracker::TrackerWrapper &t)
858 {
859  // Common tracker attributes
860  const static std::vector<vpMbGenericTracker::vpTrackerType> trackerTypes = {
861  vpMbGenericTracker::EDGE_TRACKER,
862  #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
863  vpMbGenericTracker::KLT_TRACKER,
864  #endif
865  vpMbGenericTracker::DEPTH_DENSE_TRACKER,
866  vpMbGenericTracker::DEPTH_NORMAL_TRACKER
867  };
868  j = nlohmann::json {
869  {"camera", t.m_cam},
870  {"type", flagsToJSON(t.m_trackerType, trackerTypes)},
871  {"angleAppear", vpMath::deg(t.getAngleAppear())},
872  {"angleDisappear", vpMath::deg(t.getAngleDisappear())},
873  {"lod", {
874  {"useLod", t.useLodGeneral},
875  {"minLineLengthThresholdGeneral", t.minLineLengthThresholdGeneral},
876  {"minPolygonAreaThresholdGeneral", t.minPolygonAreaThresholdGeneral}
877  }},
878  {"display", {
879  {"features", t.displayFeatures},
880  {"projectionError", t.m_projectionErrorDisplay}
881  }},
882  {"visibilityTest", {
883  {"ogre", t.useOgre},
884  {"scanline", t.useScanLine}
885  }},
886  {"clipping", {
887  {"flags", clippingFlagsToJSON(t.getClipping())},
888  {"near", t.getNearClippingDistance()},
889  {"far", t.getFarClippingDistance()},
890  }}
891  };
892  //Check tracker type: for each type, add settings to json if the tracker t does use the features
893  //Edge tracker settings
894  if (t.m_trackerType & vpMbGenericTracker::EDGE_TRACKER) {
895  j["edge"] = t.me;
896  }
897  //KLT tracker settings
898 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
899  if (t.m_trackerType & vpMbGenericTracker::KLT_TRACKER) {
900  nlohmann::json klt = nlohmann::json {
901  {"maxFeatures", t.tracker.getMaxFeatures()},
902  {"windowSize", t.tracker.getWindowSize()},
903  {"quality", t.tracker.getQuality()},
904  {"minDistance", t.tracker.getMinDistance()},
905  {"harris", t.tracker.getHarrisFreeParameter()},
906  {"blockSize", t.tracker.getBlockSize()},
907  {"pyramidLevels", t.tracker.getPyramidLevels()}
908  };
909  klt["maskBorder"] = t.maskBorder;
910  j["klt"] = klt;
911  }
912 #endif
913  //Depth normal settings
914  if (t.m_trackerType & vpMbGenericTracker::DEPTH_NORMAL_TRACKER) {
915  j["normals"] = nlohmann::json {
916  {"featureEstimationMethod", t.m_depthNormalFeatureEstimationMethod},
917  {"pcl", {
918  {"method", t.m_depthNormalPclPlaneEstimationMethod},
919  {"ransacMaxIter", t.m_depthNormalPclPlaneEstimationRansacMaxIter},
920  {"ransacThreshold", t.m_depthNormalPclPlaneEstimationRansacThreshold}
921  }},
922  {"sampling", {
923  {"x", t.m_depthNormalSamplingStepX},
924  {"y", t.m_depthNormalSamplingStepY}
925  }}
926  };
927  }
928  //Depth dense settings
929  if (t.m_trackerType & vpMbGenericTracker::DEPTH_DENSE_TRACKER) {
930  j["dense"] = {
931  {"sampling", {
932  {"x", t.m_depthDenseSamplingStepX},
933  {"y", t.m_depthDenseSamplingStepY}
934  }}
935  };
936  }
937 }
958 inline void from_json(const nlohmann::json &j, vpMbGenericTracker::TrackerWrapper &t)
959 {
960  t.setCameraParameters(j.at("camera"));
961  t.setTrackerType(flagsFromJSON<vpMbGenericTracker::vpTrackerType>(j.at("type")));
962  //Load base settings
963  if (j.contains("angleAppear")) {
964  t.setAngleAppear(vpMath::rad(static_cast<double>(j.at("angleAppear"))));
965  }
966  if (j.contains("angleDisappear")) {
967  t.setAngleDisappear(vpMath::rad(static_cast<double>(j.at("angleDisappear"))));
968  }
969  if (j.contains("clipping")) {
970  const nlohmann::json clipping = j["clipping"];
971  t.setNearClippingDistance(clipping.value("near", t.getNearClippingDistance()));
972  t.setFarClippingDistance(clipping.value("far", t.getFarClippingDistance()));
973  if (clipping.contains("flags")) {
974  t.setClipping(flagsFromJSON<vpPolygon3D::vpPolygon3DClippingType>(clipping.at("flags")));
975  }
976  }
977  if (j.contains("lod")) {
978  const nlohmann::json lod = j["lod"];
979  t.useLodGeneral = lod.value("useLod", t.useLodGeneral);
980  t.minLineLengthThresholdGeneral = lod.value("minLineLengthThresholdGeneral", t.minLineLengthThresholdGeneral);
981  t.minPolygonAreaThresholdGeneral = lod.value("minPolygonAreaThresholdGeneral", t.minPolygonAreaThresholdGeneral);
982  t.applyLodSettingInConfig = false;
983  if (t.getNbPolygon() > 0) {
984  t.applyLodSettingInConfig = true;
985  t.setLod(t.useLodGeneral);
986  t.setMinLineLengthThresh(t.minLineLengthThresholdGeneral);
987  t.setMinPolygonAreaThresh(t.minPolygonAreaThresholdGeneral);
988  }
989  }
990  if (j.contains("display")) {
991  const nlohmann::json displayJson = j["display"];
992  t.setDisplayFeatures(displayJson.value("features", t.displayFeatures));
993  t.setProjectionErrorDisplay(displayJson.value("projectionError", t.m_projectionErrorDisplay));
994  }
995  if (j.contains("visibilityTest")) {
996  const nlohmann::json visJson = j["visibilityTest"];
997  t.setOgreVisibilityTest(visJson.value("ogre", t.useOgre));
998  t.setScanLineVisibilityTest(visJson.value("scanline", t.useScanLine));
999  }
1000 
1001  //Check tracker type: for each type, load settings for this specific tracker type
1002  //Edge tracker settings
1003  if (t.m_trackerType & vpMbGenericTracker::EDGE_TRACKER) {
1004  from_json(j.at("edge"), t.me);
1005  }
1006  //KLT tracker settings
1007 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
1008  if (t.m_trackerType & vpMbGenericTracker::KLT_TRACKER) {
1009  const nlohmann::json klt = j.at("klt");
1010  auto &ktrack = t.tracker;
1011  ktrack.setMaxFeatures(klt.value("maxFeatures", 10000));
1012  ktrack.setWindowSize(klt.value("windowSize", 5));
1013  ktrack.setQuality(klt.value("quality", 0.01));
1014  ktrack.setMinDistance(klt.value("minDistance", 5));
1015  ktrack.setHarrisFreeParameter(klt.value("harris", 0.01));
1016  ktrack.setBlockSize(klt.value("blockSize", 3));
1017  ktrack.setPyramidLevels(klt.value("pyramidLevels", 3));
1018  t.setMaskBorder(klt.value("maskBorder", t.maskBorder));
1019  t.faces.getMbScanLineRenderer().setMaskBorder(t.maskBorder);
1020  }
1021 #else
1022  if (j.contains("klt")) {
1023  std::cerr << "Trying to load a KLT tracker, but the ViSP dependency requirements are not met. Ignoring." << std::endl;
1024  }
1025 #endif
1026  //Depth normal settings
1027  if (t.m_trackerType & vpMbGenericTracker::DEPTH_NORMAL_TRACKER) {
1028  const nlohmann::json n = j.at("normals");
1029  t.setDepthNormalFeatureEstimationMethod(n.at("featureEstimationMethod"));
1030  if (n.contains("pcl")) {
1031  const nlohmann::json pcl = n["pcl"];
1032  t.setDepthNormalPclPlaneEstimationMethod(pcl.at("method"));
1033  t.setDepthNormalPclPlaneEstimationRansacMaxIter(pcl.at("ransacMaxIter"));
1034  t.setDepthNormalPclPlaneEstimationRansacThreshold(pcl.at("ransacThreshold"));
1035  }
1036  if (n.contains("sampling")) {
1037  const nlohmann::json sampling = n.at("sampling");
1038  t.setDepthNormalSamplingStep(sampling.at("x"), sampling.at("y"));
1039  }
1040  }
1041  //Depth Dense settings
1042  if (t.m_trackerType & vpMbGenericTracker::DEPTH_DENSE_TRACKER) {
1043  const nlohmann::json dense = j.at("dense");
1044  if (dense.contains("sampling")) {
1045  const nlohmann::json sampling = dense.at("sampling");
1046  t.setDepthDenseSamplingStep(sampling.at("x"), sampling.at("y"));
1047  }
1048  }
1049 }
1050 
1051 #endif
1052 
1053 
1054 #endif
vpCameraParameters
Generic class defining intrinsic camera parameters.
Definition: vpCameraParameters.h:304
vpColVector
Implementation of column vector and the associated operations.
Definition: vpColVector.h:167
vpColor
Class to define RGB colors available for display functionalities.
Definition: vpColor.h:152
vpHomogeneousMatrix
Implementation of an homogeneous matrix and operations on such kind of matrices.
Definition: vpHomogeneousMatrix.h:201
vpKltOpencv
Wrapper for the KLT (Kanade-Lucas-Tomasi) feature tracker implemented in OpenCV. Thus to enable this ...
Definition: vpKltOpencv.h:73
vpMath::rad
static double rad(double deg)
Definition: vpMath.h:116
vpMath::deg
static double deg(double rad)
Definition: vpMath.h:106
vpMatrix
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:152
vpMbDepthDenseTracker::setPose
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
Definition: vpMbDepthDenseTracker.cpp:669
vpMbDepthDenseTracker::track
virtual void track(const vpImage< unsigned char > &)
Definition: vpMbDepthDenseTracker.cpp:715
vpMbDepthNormalTracker::setPose
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
Definition: vpMbDepthNormalTracker.cpp:543
vpMbDepthNormalTracker::track
virtual void track(const vpImage< unsigned char > &)
Definition: vpMbDepthNormalTracker.cpp:789
vpMbEdgeTracker
Make the complete tracking of an object by using its CAD model.
Definition: vpMbEdgeTracker.h:242
vpMbEdgeTracker::computeVVSInteractionMatrixAndResidu
virtual void computeVVSInteractionMatrixAndResidu()
Definition: vpMbEdgeTracker.cpp:758
vpMbEdgeTracker::track
virtual void track(const vpImage< unsigned char > &I)
Definition: vpMbEdgeTracker.cpp:1019
vpMbGenericTracker
Real-time 6D object pose tracking using its CAD model.
Definition: vpMbGenericTracker.h:200
vpMbGenericTracker::setCameraParameters
virtual void setCameraParameters(const vpCameraParameters &camera)
Definition: vpMbGenericTracker.cpp:3807
vpMbGenericTracker::getFeaturesForDisplay
virtual std::vector< std::vector< double > > getFeaturesForDisplay()
Definition: vpMbGenericTracker.cpp:1030
vpMbGenericTracker::getTrackerType
virtual int getTrackerType() const
Definition: vpMbGenericTracker.cpp:1811
vpMbGenericTracker::m_mapOfTrackers
std::map< std::string, TrackerWrapper * > m_mapOfTrackers
Definition: vpMbGenericTracker.h:807
vpMbGenericTracker::setProjectionErrorComputation
virtual void setProjectionErrorComputation(const bool &flag)
Definition: vpMbGenericTracker.cpp:5074
vpMbGenericTracker::m_nb_feat_edge
unsigned int m_nb_feat_edge
Number of moving-edges features.
Definition: vpMbGenericTracker.h:822
vpMbGenericTracker::getNbFeaturesEdge
virtual unsigned int getNbFeaturesEdge() const
Definition: vpMbGenericTracker.h:331
vpMbGenericTracker::m_mapOfCameraTransformationMatrix
std::map< std::string, vpHomogeneousMatrix > m_mapOfCameraTransformationMatrix
Definition: vpMbGenericTracker.h:802
vpMbGenericTracker::getModelForDisplay
virtual std::vector< std::vector< double > > getModelForDisplay(unsigned int width, unsigned int height, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, bool displayFullModel=false)
Definition: vpMbGenericTracker.cpp:1436
vpMbGenericTracker::computeVVSInteractionMatrixAndResidu
virtual void computeVVSInteractionMatrixAndResidu()
Definition: vpMbGenericTracker.cpp:563
vpMbGenericTracker::to_json
friend void to_json(nlohmann::json &j, const TrackerWrapper &t)
Serialize a tracker wrapper's settings into a JSON representation.
Definition: vpMbGenericTracker.h:857
vpMbGenericTracker::m_w
vpColVector m_w
Robust weights.
Definition: vpMbGenericTracker.h:817
vpMbGenericTracker::setNearClippingDistance
virtual void setNearClippingDistance(const double &dist)
Definition: vpMbGenericTracker.cpp:4642
vpMbGenericTracker::getNbFeaturesKlt
virtual unsigned int getNbFeaturesKlt() const
Definition: vpMbGenericTracker.h:335
vpMbGenericTracker::m_nb_feat_depthDense
unsigned int m_nb_feat_depthDense
Number of depth dense features.
Definition: vpMbGenericTracker.h:828
vpMbGenericTracker::initFaceFromCorners
virtual void initFaceFromCorners(vpMbtPolygon &polygon)
Definition: vpMbGenericTracker.cpp:2199
vpMbGenericTracker::getRobustWeights
virtual vpColVector getRobustWeights() const
Definition: vpMbGenericTracker.h:359
vpMbGenericTracker::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: vpMbGenericTracker.cpp:3290
vpMbGenericTracker::setScanLineVisibilityTest
virtual void setScanLineVisibilityTest(const bool &v)
Definition: vpMbGenericTracker.cpp:5140
vpMbGenericTracker::getNbFeaturesDepthDense
virtual unsigned int getNbFeaturesDepthDense() const
Definition: vpMbGenericTracker.h:321
vpMbGenericTracker::m_weightedError
vpColVector m_weightedError
Weighted error.
Definition: vpMbGenericTracker.h:819
vpMbGenericTracker::m_L
vpMatrix m_L
Interaction matrix.
Definition: vpMbGenericTracker.h:799
vpMbGenericTracker::init
virtual void init(const vpImage< unsigned char > &I)
Definition: vpMbGenericTracker.cpp:1824
vpMbGenericTracker::computeVVSWeights
virtual void computeVVSWeights()
Definition: vpMbGenericTracker.cpp:596
vpMbGenericTracker::computeVVSInit
virtual void computeVVSInit()
Definition: vpMbGenericTracker.cpp:538
vpMbGenericTracker::getNbFeaturesDepthNormal
virtual unsigned int getNbFeaturesDepthNormal() const
Definition: vpMbGenericTracker.h:325
vpMbGenericTracker::m_error
vpColVector m_error
(s - s*)
Definition: vpMbGenericTracker.h:797
vpMbGenericTracker::m_mapOfFeatureFactors
std::map< vpTrackerType, double > m_mapOfFeatureFactors
Ponderation between each feature type in the VVS stage.
Definition: vpMbGenericTracker.h:804
vpMbGenericTracker::computeVVS
virtual void computeVVS(std::map< std::string, const vpImage< unsigned char > * > &mapOfImages)
Definition: vpMbGenericTracker.cpp:291
vpMbGenericTracker::initCylinder
virtual void initCylinder(const vpPoint &p1, const vpPoint &p2, double radius, int idFace=0, const std::string &name="")
Definition: vpMbGenericTracker.cpp:2193
vpMbGenericTracker::setTrackerType
virtual void setTrackerType(int type)
Definition: vpMbGenericTracker.cpp:5162
vpMbGenericTracker::m_nb_feat_klt
unsigned int m_nb_feat_klt
Number of klt features.
Definition: vpMbGenericTracker.h:824
vpMbGenericTracker::initFaceFromLines
virtual void initFaceFromLines(vpMbtPolygon &polygon)
Definition: vpMbGenericTracker.cpp:2204
vpMbGenericTracker::m_nb_feat_depthNormal
unsigned int m_nb_feat_depthNormal
Number of depth normal features.
Definition: vpMbGenericTracker.h:826
vpMbGenericTracker::setFarClippingDistance
virtual void setFarClippingDistance(const double &dist)
Definition: vpMbGenericTracker.cpp:4216
vpMbGenericTracker::initCircle
virtual void initCircle(const vpPoint &p1, const vpPoint &p2, const vpPoint &p3, double radius, int idFace=0, const std::string &name="")
Definition: vpMbGenericTracker.cpp:1834
vpMbGenericTracker::preTracking
virtual void preTracking(std::map< std::string, const vpImage< unsigned char > * > &mapOfImages, std::map< std::string, pcl::PointCloud< pcl::PointXYZ >::ConstPtr > &mapOfPointClouds)
Definition: vpMbGenericTracker.cpp:3255
vpMbGenericTracker::setClipping
virtual void setClipping(const unsigned int &flags)
Definition: vpMbGenericTracker.cpp:3925
vpMbGenericTracker::loadConfigFile
virtual void loadConfigFile(const std::string &configFile, bool verbose=true)
Definition: vpMbGenericTracker.cpp:2867
vpMbGenericTracker::setPose
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
Definition: vpMbGenericTracker.cpp:4788
vpMbGenericTracker::setOgreVisibilityTest
virtual void setOgreVisibilityTest(const bool &v)
Definition: vpMbGenericTracker.cpp:4739
vpMbGenericTracker::m_referenceCameraName
std::string m_referenceCameraName
Name of the reference camera.
Definition: vpMbGenericTracker.h:812
vpMbGenericTracker::getError
virtual vpColVector getError() const
Definition: vpMbGenericTracker.h:259
vpMbGenericTracker::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: vpMbGenericTracker.cpp:623
vpMbGenericTracker::from_json
friend void from_json(const nlohmann::json &j, TrackerWrapper &t)
Load configuration settings from a JSON object for a tracker wrapper.
Definition: vpMbGenericTracker.h:958
vpMbGenericTracker::track
virtual void track(const vpImage< unsigned char > &I)
Definition: vpMbGenericTracker.cpp:5298
vpMbKltTracker
Model based tracker using only KLT.
Definition: vpMbKltTracker.h:207
vpMbTracker
Main methods for a model-based tracker.
Definition: vpMbTracker.h:105
vpMbTracker::setProjectionErrorDisplayArrowLength
virtual void setProjectionErrorDisplayArrowLength(unsigned int length)
Definition: vpMbTracker.h:595
vpMbTracker::computeCurrentProjectionError
virtual double computeCurrentProjectionError(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &_cMo, const vpCameraParameters &_cam)
Definition: vpMbTracker.cpp:3426
vpMbTracker::track
virtual void track(const vpImage< unsigned char > &I)=0
vpMbTracker::resetTracker
virtual void resetTracker()=0
vpMbTracker::setOgreShowConfigDialog
virtual void setOgreShowConfigDialog(bool showConfigDialog)
Definition: vpMbTracker.h:647
vpMbTracker::setMask
virtual void setMask(const vpImage< bool > &mask)
Definition: vpMbTracker.h:564
vpMbTracker::setMinLineLengthThresh
virtual void setMinLineLengthThresh(double minLineLengthThresh, const std::string &name="")
Definition: vpMbTracker.cpp:2735
vpMbTracker::getCameraParameters
virtual void getCameraParameters(vpCameraParameters &cam) const
Definition: vpMbTracker.h:248
vpMbTracker::init
virtual void init(const vpImage< unsigned char > &I)=0
vpMbTracker::setDisplayFeatures
virtual void setDisplayFeatures(bool displayF)
Definition: vpMbTracker.h:518
vpMbTracker::initFromPoints
virtual void initFromPoints(const vpImage< unsigned char > &I, const std::string &initFile)
Definition: vpMbTracker.cpp:962
vpMbTracker::getPose
virtual vpHomogeneousMatrix getPose() const
Definition: vpMbTracker.h:423
vpMbTracker::getModelForDisplay
virtual std::vector< std::vector< double > > getModelForDisplay(unsigned int width, unsigned int height, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, bool displayFullModel=false)=0
vpMbTracker::setMinPolygonAreaThresh
virtual void setMinPolygonAreaThresh(double minPolygonAreaThresh, const std::string &name="")
Definition: vpMbTracker.cpp:2752
vpMbTracker::initFaceFromLines
virtual void initFaceFromLines(vpMbtPolygon &polygon)=0
vpMbTracker::initCircle
virtual void initCircle(const vpPoint &p1, const vpPoint &p2, const vpPoint &p3, double radius, int idFace=0, const std::string &name="")=0
vpMbTracker::initCylinder
virtual void initCylinder(const vpPoint &p1, const vpPoint &p2, double radius, int idFace=0, const std::string &name="")=0
vpMbTracker::computeVVSWeights
virtual void computeVVSWeights(vpRobust &robust, const vpColVector &error, vpColVector &w)
Definition: vpMbTracker.cpp:2926
vpMbTracker::setCameraParameters
virtual void setCameraParameters(const vpCameraParameters &cam)
Definition: vpMbTracker.h:488
vpMbTracker::setAngleDisappear
virtual void setAngleDisappear(const double &a)
Definition: vpMbTracker.h:481
vpMbTracker::setNbRayCastingAttemptsForVisibility
virtual void setNbRayCastingAttemptsForVisibility(const unsigned int &attempts)
Definition: vpMbTracker.h:631
vpMbTracker::setScanLineVisibilityTest
virtual void setScanLineVisibilityTest(const bool &v)
Definition: vpMbTracker.h:605
vpMbTracker::getFaces
virtual vpMbHiddenFaces< vpMbtPolygon > & getFaces()
Definition: vpMbTracker.h:332
vpMbTracker::setOgreVisibilityTest
virtual void setOgreVisibilityTest(const bool &v)
Definition: vpMbTracker.cpp:2669
vpMbTracker::initClick
virtual void initClick(const vpImage< unsigned char > &I, const std::string &initFile, bool displayHelp=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbTracker.cpp:584
vpMbTracker::setLod
virtual void setLod(bool useLod, const std::string &name="")
Definition: vpMbTracker.cpp:2717
vpMbTracker::setPose
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)=0
vpMbTracker::setProjectionErrorDisplay
virtual void setProjectionErrorDisplay(bool display)
Definition: vpMbTracker.h:590
vpMbTracker::getNbPolygon
virtual unsigned int getNbPolygon() const
Definition: vpMbTracker.h:368
vpMbTracker::setNearClippingDistance
virtual void setNearClippingDistance(const double &dist)
Definition: vpMbTracker.cpp:2766
vpMbTracker::setFarClippingDistance
virtual void setFarClippingDistance(const double &dist)
Definition: vpMbTracker.cpp:2687
vpMbTracker::getPolygon
virtual vpMbtPolygon * getPolygon(unsigned int index)
Definition: vpMbTracker.h:395
vpMbTracker::setProjectionErrorComputation
virtual void setProjectionErrorComputation(const bool &flag)
Definition: vpMbTracker.h:585
vpMbTracker::setClipping
virtual void setClipping(const unsigned int &flags)
Definition: vpMbTracker.cpp:2793
vpMbTracker::setOptimizationMethod
virtual void setOptimizationMethod(const vpMbtOptimizationMethod &opt)
Definition: vpMbTracker.h:558
vpMbTracker::computeVVSInteractionMatrixAndResidu
virtual void computeVVSInteractionMatrixAndResidu()=0
vpMbTracker::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)=0
vpMbTracker::initFromPose
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
Definition: vpMbTracker.cpp:1110
vpMbTracker::setProjectionErrorDisplayArrowThickness
virtual void setProjectionErrorDisplayArrowThickness(unsigned int thickness)
Definition: vpMbTracker.h:600
vpMbTracker::loadModel
virtual void loadModel(const std::string &modelFile, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
Definition: vpMbTracker.cpp:1424
vpMbTracker::setAngleAppear
virtual void setAngleAppear(const double &a)
Definition: vpMbTracker.h:470
vpMbTracker::setGoodNbRayCastingAttemptsRatio
virtual void setGoodNbRayCastingAttemptsRatio(const double &ratio)
Definition: vpMbTracker.h:621
vpMbTracker::computeVVSInit
virtual void computeVVSInit()=0
vpMbTracker::getPolygonFaces
virtual std::pair< std::vector< vpPolygon >, std::vector< std::vector< vpPoint > > > getPolygonFaces(bool orderPolygons=true, bool useVisibility=true, bool clipPolygon=false)
Definition: vpMbTracker.cpp:2579
vpMbTracker::testTracking
virtual void testTracking()=0
vpMbTracker::initFaceFromCorners
virtual void initFaceFromCorners(vpMbtPolygon &polygon)=0
vpMbTracker::getClipping
virtual unsigned int getClipping() const
Definition: vpMbTracker.h:256
vpMbTracker::loadConfigFile
virtual void loadConfigFile(const std::string &configFile, bool verbose=true)
Definition: vpMbTracker.cpp:3729
vpMbtPolygon
Implementation of a polygon of the model used by the model-based tracker.
Definition: vpMbtPolygon.h:65
vpMe
Definition: vpMe.h:122
vpPoint
Class that defines a 3D point in the object frame and allows forward projection of a 3D point in the ...
Definition: vpPoint.h:77