Visual Servoing Platform version 3.5.0
vpMbtDistanceCylinder.h
1/****************************************************************************
2 *
3 * ViSP, open source Visual Servoing Platform software.
4 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5 *
6 * This software is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 * See the file LICENSE.txt at the root directory of this source
11 * distribution for additional information about the GNU GPL.
12 *
13 * For using ViSP with software that can not be combined with the GNU
14 * GPL, please contact Inria about acquiring a ViSP Professional
15 * Edition License.
16 *
17 * See http://visp.inria.fr for more information.
18 *
19 * This software was developed at:
20 * Inria Rennes - Bretagne Atlantique
21 * Campus Universitaire de Beaulieu
22 * 35042 Rennes Cedex
23 * France
24 *
25 * If you have questions regarding the use of this file, please contact
26 * Inria at visp@inria.fr
27 *
28 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30 *
31 * Description:
32 * Manage a cylinder used in the model-based tracker.
33 *
34 * Authors:
35 * Nicolas Melchior
36 * Romain Tallonneau
37 * Eric Marchand
38 * Bertrand Delabarre
39 *
40 *****************************************************************************/
41
47#ifndef vpMbtDistanceCylinder_HH
48#define vpMbtDistanceCylinder_HH
49
50#include <visp3/core/vpCircle.h>
51#include <visp3/core/vpCylinder.h>
52#include <visp3/core/vpHomogeneousMatrix.h>
53#include <visp3/core/vpLine.h>
54#include <visp3/core/vpPoint.h>
55#include <visp3/mbt/vpMbHiddenFaces.h>
56#include <visp3/mbt/vpMbtMeLine.h>
57#include <visp3/visual_features/vpFeatureLine.h>
58
66class VISP_EXPORT vpMbtDistanceCylinder
67{
68private:
69 std::string name;
70 unsigned int index;
72 vpMe *me;
73 double wmean1;
74 double wmean2;
75 vpFeatureLine featureline1;
76 vpFeatureLine featureline2;
77 bool isTrackedCylinder;
78
79public:
81 vpMbtMeLine *meline1;
83 vpMbtMeLine *meline2;
84
89
91 double radius;
92
97
103 unsigned int nbFeature;
105 unsigned int nbFeaturel1;
107 unsigned int nbFeaturel2;
109 bool Reinit;
112
119
120 // private:
121 //#ifndef DOXYGEN_SHOULD_SKIP_THIS
122 // vpMbtDistanceCylinder(const vpMbtDistanceCylinder &)
123 // : name(), index(0), cam(), me(NULL), wmean1(1), wmean2(1),
124 // featureline1(), featureline2(), isTrackedCylinder(true),
125 // meline1(NULL), meline2(NULL), cercle1(NULL), cercle2(NULL),
126 // radius(0), p1(NULL), p2(NULL), L(), error(), nbFeature(0),
127 // nbFeaturel1(0), nbFeaturel2(0), Reinit(false), c(NULL),
128 // hiddenface(NULL), index_polygon(-1), isvisible(false)
129 // {
130 // throw vpException(vpException::functionNotImplementedError, "Not
131 // implemented!");
132 // }
133 // vpMbtDistanceCylinder &operator=(const vpMbtDistanceCylinder &){
134 // throw vpException(vpException::functionNotImplementedError, "Not
135 // implemented!"); return *this;
136 // }
137 //#endif
138
139public:
141 virtual ~vpMbtDistanceCylinder();
142
143 void buildFrom(const vpPoint &_p1, const vpPoint &_p2, double r);
144
145 void computeInteractionMatrixError(const vpHomogeneousMatrix &cMo, const vpImage<unsigned char> &I);
146
147 void display(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
148 const vpColor &col, unsigned int thickness = 1, bool displayFullModel = false);
149 void display(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
150 const vpColor &col, unsigned int thickness = 1, bool displayFullModel = false);
151 void displayMovingEdges(const vpImage<unsigned char> &I);
152 void displayMovingEdges(const vpImage<vpRGBa> &I);
153
159 inline void getCameraParameters(vpCameraParameters &camera) { camera = this->cam; }
160
166 inline unsigned int getIndex() { return index; }
167
175 inline double getMeanWeight1() const { return wmean1; }
176
184 inline double getMeanWeight2() const { return wmean2; }
185
186 std::vector<std::vector<double> > getFeaturesForDisplay();
187
188 std::vector<std::vector<double> > getModelForDisplay(unsigned int width, unsigned int height,
189 const vpHomogeneousMatrix &cMo,
190 const vpCameraParameters &cam,
191 bool displayFullModel = false);
192
198 inline std::string getName() const { return name; }
199
200 void initInteractionMatrixError();
201
202 bool initMovingEdge(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo, bool doNotTrack,
203 const vpImage<bool> *mask = NULL);
204
210 inline bool isTracked() const { return isTrackedCylinder; }
211
217 inline bool isVisible() const { return isvisible; }
218
219 void reinitMovingEdge(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo,
220 const vpImage<bool> *mask = NULL);
221
226 inline void setCameraParameters(const vpCameraParameters &camera) { this->cam = camera; }
227
233 inline void setTracked(const bool &track) { this->isTrackedCylinder = track; }
234
240 inline void setIndex(unsigned int i) { index = i; }
241
247 inline void setMeanWeight1(double wmean) { this->wmean1 = wmean; }
248
254 inline void setMeanWeight2(double wmean) { this->wmean2 = wmean; }
255
256 void setMovingEdge(vpMe *Me);
257
263 inline void setName(const std::string &cyl_name) { this->name = cyl_name; }
264
270 inline void setName(const char *cyl_name) { this->name = std::string(cyl_name); }
271
278 inline void setVisible(bool _isvisible) { isvisible = _isvisible; }
279
280 void trackMovingEdge(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo);
281
282 void updateMovingEdge(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo);
283
284private:
285 void project(const vpHomogeneousMatrix &cMo);
286};
287
288#endif
Generic class defining intrinsic camera parameters.
Class that defines a 3D circle in the object frame and allows forward projection of a 3D circle in th...
Definition: vpCircle.h:92
Implementation of column vector and the associated operations.
Definition: vpColVector.h:131
Class to define RGB colors available for display functionnalities.
Definition: vpColor.h:158
Class that defines a 3D cylinder in the object frame and allows forward projection of a 3D cylinder i...
Definition: vpCylinder.h:103
Class that defines a 2D line visual feature which is composed by two parameters that are and ,...
Implementation of an homogeneous matrix and operations on such kind of matrices.
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:154
Manage a cylinder used in the model-based tracker.
void setMeanWeight1(double wmean)
void setCameraParameters(const vpCameraParameters &camera)
void setName(const std::string &cyl_name)
vpMbtMeLine * meline2
The moving edge containers (second line of the cylinder)
void setVisible(bool _isvisible)
void getCameraParameters(vpCameraParameters &camera)
vpCylinder * c
The cylinder.
vpMatrix L
The interaction matrix.
unsigned int nbFeaturel2
The number of moving edges on line 2.
bool Reinit
Indicates if the line has to be reinitialized.
vpPoint * p2
The second extremity on the axe.
vpCircle * cercle1
The upper circle limiting the cylinder.
vpMbHiddenFaces< vpMbtPolygon > * hiddenface
Pointer to the list of faces.
void setMeanWeight2(double wmean)
double radius
The radius of the cylinder.
unsigned int nbFeaturel1
The number of moving edges on line 1.
vpColVector error
The error vector.
void setTracked(const bool &track)
std::string getName() const
void setName(const char *cyl_name)
unsigned int nbFeature
The number of moving edges.
int index_polygon
Index of the face which contains the cylinder.
vpCircle * cercle2
The lower circle limiting the cylinder.
bool isvisible
Indicates if the cylinder is visible or not.
void setIndex(unsigned int i)
vpPoint * p1
The first extremity on the axe.
vpMbtMeLine * meline1
The moving edge containers (first line of the cylinder)
Definition: vpMe.h:61
Class that defines a 3D point in the object frame and allows forward projection of a 3D point in the ...
Definition: vpPoint.h:82