Visual Servoing Platform version 3.6.0
Loading...
Searching...
No Matches
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
199class VISP_EXPORT vpMbGenericTracker : public vpMbTracker
200{
201public:
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
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
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
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
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
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
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
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,
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,
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
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
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,
429 virtual void loadModel(const std::string &modelFile1, const std::string &modelFile2, bool verbose = false,
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,
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,
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
607protected:
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);
615 virtual void computeVVSInteractionMatrixAndResidu(std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
616 std::map<std::string, vpVelocityTwistMatrix> &mapOfVelocityTwist);
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
644private:
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
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,
701 virtual void reInitModel(const vpImage<vpRGBa> &I_color, const std::string &cad_name,
702 const vpHomogeneousMatrix &cMo, bool verbose = false,
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))
735#endif
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();
748 virtual void computeVVSInteractionMatrixAndResidu(const vpImage<unsigned char> *const ptr_I);
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,
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))
784#endif
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
795protected:
802 std::map<std::string, vpHomogeneousMatrix> m_mapOfCameraTransformationMatrix;
804 std::map<vpTrackerType, double> m_mapOfFeatureFactors;
807 std::map<std::string, TrackerWrapper *> m_mapOfTrackers;
820
822 unsigned int m_nb_feat_edge;
824 unsigned int m_nb_feat_klt;
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)
837NLOHMANN_JSON_SERIALIZE_ENUM(vpMbGenericTracker::vpTrackerType, {
842 });
843#else
844NLOHMANN_JSON_SERIALIZE_ENUM(vpMbGenericTracker::vpTrackerType, {
848 });
849#endif
850
857inline void to_json(nlohmann::json &j, const vpMbGenericTracker::TrackerWrapper &t)
858{
859 // Common tracker attributes
860 const static std::vector<vpMbGenericTracker::vpTrackerType> trackerTypes = {
862 #if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
864 #endif
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}
958inline 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
Generic class defining intrinsic camera parameters.
Implementation of column vector and the associated operations.
Class to define RGB colors available for display functionalities.
Definition vpColor.h:152
Implementation of an homogeneous matrix and operations on such kind of matrices.
Definition of the vpImage class member functions.
Definition vpImage.h:135
Wrapper for the KLT (Kanade-Lucas-Tomasi) feature tracker implemented in OpenCV. Thus to enable this ...
Definition vpKltOpencv.h:73
static double rad(double deg)
Definition vpMath.h:116
static double deg(double rad)
Definition vpMath.h:106
Implementation of a matrix and operations on matrices.
Definition vpMatrix.h:152
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
virtual void track(const vpImage< unsigned char > &)
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
virtual void track(const vpImage< unsigned char > &)
Make the complete tracking of an object by using its CAD model.
virtual void computeVVSInteractionMatrixAndResidu()
virtual void track(const vpImage< unsigned char > &I)
Real-time 6D object pose tracking using its CAD model.
std::map< std::string, TrackerWrapper * > m_mapOfTrackers
unsigned int m_nb_feat_edge
Number of moving-edges features.
virtual unsigned int getNbFeaturesEdge() const
std::map< std::string, vpHomogeneousMatrix > m_mapOfCameraTransformationMatrix
friend void to_json(nlohmann::json &j, const TrackerWrapper &t)
Serialize a tracker wrapper's settings into a JSON representation.
vpColVector m_w
Robust weights.
virtual unsigned int getNbFeaturesKlt() const
unsigned int m_nb_feat_depthDense
Number of depth dense features.
virtual vpColVector getRobustWeights() const
virtual unsigned int getNbFeaturesDepthDense() const
vpColVector m_weightedError
Weighted error.
vpMatrix m_L
Interaction matrix.
virtual unsigned int getNbFeaturesDepthNormal() const
vpColVector m_error
(s - s*)
std::map< vpTrackerType, double > m_mapOfFeatureFactors
Ponderation between each feature type in the VVS stage.
unsigned int m_nb_feat_klt
Number of klt features.
unsigned int m_nb_feat_depthNormal
Number of depth normal features.
std::string m_referenceCameraName
Name of the reference camera.
virtual vpColVector getError() const
friend void from_json(const nlohmann::json &j, TrackerWrapper &t)
Load configuration settings from a JSON object for a tracker wrapper.
Implementation of the polygons management for the model-based trackers.
Model based tracker using only KLT.
Main methods for a model-based tracker.
virtual void setProjectionErrorDisplayArrowLength(unsigned int length)
virtual double computeCurrentProjectionError(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &_cMo, const vpCameraParameters &_cam)
virtual void track(const vpImage< unsigned char > &I)=0
virtual void resetTracker()=0
virtual void setOgreShowConfigDialog(bool showConfigDialog)
virtual void setMask(const vpImage< bool > &mask)
virtual void setMinLineLengthThresh(double minLineLengthThresh, const std::string &name="")
virtual void getCameraParameters(vpCameraParameters &cam) const
virtual void init(const vpImage< unsigned char > &I)=0
virtual void setDisplayFeatures(bool displayF)
virtual void initFromPoints(const vpImage< unsigned char > &I, const std::string &initFile)
virtual vpHomogeneousMatrix getPose() const
virtual void setMinPolygonAreaThresh(double minPolygonAreaThresh, const std::string &name="")
virtual void initFaceFromLines(vpMbtPolygon &polygon)=0
virtual void initCircle(const vpPoint &p1, const vpPoint &p2, const vpPoint &p3, double radius, int idFace=0, const std::string &name="")=0
virtual void initCylinder(const vpPoint &p1, const vpPoint &p2, double radius, int idFace=0, const std::string &name="")=0
virtual vpMbHiddenFaces< vpMbtPolygon > & getFaces()
virtual void computeVVSWeights(vpRobust &robust, const vpColVector &error, vpColVector &w)
virtual std::vector< std::vector< double > > getModelForDisplay(unsigned int width, unsigned int height, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, bool displayFullModel=false)=0
virtual void setCameraParameters(const vpCameraParameters &cam)
virtual void setAngleDisappear(const double &a)
virtual void setNbRayCastingAttemptsForVisibility(const unsigned int &attempts)
virtual void setScanLineVisibilityTest(const bool &v)
virtual void setOgreVisibilityTest(const bool &v)
virtual void initClick(const vpImage< unsigned char > &I, const std::string &initFile, bool displayHelp=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
virtual void setLod(bool useLod, const std::string &name="")
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)=0
virtual void setProjectionErrorDisplay(bool display)
virtual unsigned int getNbPolygon() const
virtual void setNearClippingDistance(const double &dist)
virtual void setFarClippingDistance(const double &dist)
virtual void setProjectionErrorComputation(const bool &flag)
virtual void setClipping(const unsigned int &flags)
virtual void setOptimizationMethod(const vpMbtOptimizationMethod &opt)
virtual void computeVVSInteractionMatrixAndResidu()=0
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
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
virtual void setProjectionErrorDisplayArrowThickness(unsigned int thickness)
virtual void loadModel(const std::string &modelFile, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
virtual void setAngleAppear(const double &a)
virtual void setGoodNbRayCastingAttemptsRatio(const double &ratio)
virtual void computeVVSInit()=0
virtual vpMbtPolygon * getPolygon(unsigned int index)
virtual std::pair< std::vector< vpPolygon >, std::vector< std::vector< vpPoint > > > getPolygonFaces(bool orderPolygons=true, bool useVisibility=true, bool clipPolygon=false)
virtual void testTracking()=0
virtual void initFaceFromCorners(vpMbtPolygon &polygon)=0
virtual unsigned int getClipping() const
virtual void loadConfigFile(const std::string &configFile, bool verbose=true)
Implementation of a polygon of the model used by the model-based tracker.
Definition vpMe.h:122
Class that defines a 3D point in the object frame and allows forward projection of a 3D point in the ...
Definition vpPoint.h:77