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", {
921 }},
922 {"sampling", {
925 }}
926 };
927 }
928 //Depth dense settings
929 if (t.m_trackerType & vpMbGenericTracker::DEPTH_DENSE_TRACKER) {
930 j["dense"] = {
931 {"sampling", {
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) {
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
double getQuality() const
int getMaxFeatures() const
Get the list of lost feature.
int getWindowSize() const
Get the window size used to refine the corner locations.
double getHarrisFreeParameter() const
Get the free parameter of the Harris detector.
void setMaxFeatures(int maxCount)
double getMinDistance() const
int getBlockSize() const
Get the size of the averaging block used to track the features.
int getPyramidLevels() const
Get the list of features id.
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)
unsigned int m_depthDenseSamplingStepY
Sampling step in y-direction.
unsigned int m_depthDenseSamplingStepX
Sampling step in x-direction.
virtual void track(const vpImage< unsigned char > &)
void setDepthDenseSamplingStep(unsigned int stepX, unsigned int stepY)
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
virtual void setDepthNormalSamplingStep(unsigned int stepX, unsigned int stepY)
vpMbtFaceDepthNormal::vpFeatureEstimationType m_depthNormalFeatureEstimationMethod
Method to estimate the desired features.
int m_depthNormalPclPlaneEstimationRansacMaxIter
PCL RANSAC maximum number of iterations.
unsigned int m_depthNormalSamplingStepY
Sampling step in y-direction.
double m_depthNormalPclPlaneEstimationRansacThreshold
PCL RANSAC threshold.
virtual void setDepthNormalPclPlaneEstimationRansacThreshold(double thresold)
virtual void track(const vpImage< unsigned char > &)
int m_depthNormalPclPlaneEstimationMethod
PCL plane estimation method.
virtual void setDepthNormalPclPlaneEstimationMethod(int method)
virtual void setDepthNormalFeatureEstimationMethod(const vpMbtFaceDepthNormal::vpFeatureEstimationType &method)
virtual void setDepthNormalPclPlaneEstimationRansacMaxIter(int maxIter)
unsigned int m_depthNormalSamplingStepX
Sampling step in x-direction.
Make the complete tracking of an object by using its CAD model.
vpMe me
The moving edges parameters.
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 from_json(const nlohmann::json &j, TrackerWrapper &t)
Load configuration settings from a JSON object for a tracker wrapper.
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
Implementation of the polygons management for the model-based trackers.
vpMbScanLine & getMbScanLineRenderer()
Model based tracker using only KLT.
void setMaskBorder(const unsigned int &e)
vpKltOpencv tracker
Points tracker.
unsigned int maskBorder
Erosion of the mask.
Main methods for a model-based tracker.
virtual double getNearClippingDistance() const
virtual void setProjectionErrorDisplayArrowLength(unsigned int length)
virtual double computeCurrentProjectionError(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &_cMo, const vpCameraParameters &_cam)
double minLineLengthThresholdGeneral
Minimum line length threshold for LOD mode (general setting)
bool m_projectionErrorDisplay
Display gradient and model orientation for projection error computation.
virtual void track(const vpImage< unsigned char > &I)=0
virtual void resetTracker()=0
virtual void setOgreShowConfigDialog(bool showConfigDialog)
virtual double getAngleAppear() const
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
bool useLodGeneral
True if LOD mode is enabled.
double minPolygonAreaThresholdGeneral
Minimum polygon area threshold for LOD mode (general setting)
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
vpCameraParameters m_cam
The camera parameters.
bool useOgre
Use Ogre3d for visibility tests.
virtual double getAngleDisappear() const
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
vpMbHiddenFaces< vpMbtPolygon > faces
Set of faces describing the object.
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
bool displayFeatures
If true, the features are displayed.
virtual void setProjectionErrorDisplay(bool display)
virtual unsigned int getNbPolygon() const
virtual void setNearClippingDistance(const double &dist)
bool applyLodSettingInConfig
virtual void setFarClippingDistance(const double &dist)
bool useScanLine
Use Scanline for visibility tests.
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 double getFarClippingDistance() const
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