Visual Servoing Platform version 3.5.0
vpMbtFaceDepthDense.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 depth dense features for a particular face.
33 *
34 *****************************************************************************/
35
36#ifndef _vpMbtFaceDepthDense_h_
37#define _vpMbtFaceDepthDense_h_
38
39#include <iostream>
40
41#include <visp3/core/vpConfig.h>
42#ifdef VISP_HAVE_PCL
43#include <pcl/point_cloud.h>
44#include <pcl/point_types.h>
45#endif
46
47#include <visp3/core/vpPlane.h>
48#include <visp3/mbt/vpMbTracker.h>
49#include <visp3/mbt/vpMbtDistanceLine.h>
50
51#define DEBUG_DISPLAY_DEPTH_DENSE 0
52
53class VISP_EXPORT vpMbtFaceDepthDense
54{
55public:
57 NO_FILTERING = 0,
58 DEPTH_OCCUPANCY_RATIO_FILTERING = 1 << 1,
61 MIN_DISTANCE_FILTERING = 1 << 2,
63 MAX_DISTANCE_FILTERING = 1 << 3
65 };
66
70 unsigned int m_clippingFlag;
83
85 virtual ~vpMbtFaceDepthDense();
86
87 void addLine(vpPoint &p1, vpPoint &p2, vpMbHiddenFaces<vpMbtPolygon> *const faces, vpUniRand& rand_gen, int polygon = -1,
88 std::string name = "");
89
90#ifdef VISP_HAVE_PCL
91 bool computeDesiredFeatures(const vpHomogeneousMatrix &cMo,
92 const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &point_cloud, unsigned int stepX,
93 unsigned int stepY
94#if DEBUG_DISPLAY_DEPTH_DENSE
95 ,
96 vpImage<unsigned char> &debugImage, std::vector<std::vector<vpImagePoint> > &roiPts_vec
97#endif
98 , const vpImage<bool> *mask = NULL
99 );
100#endif
101 bool computeDesiredFeatures(const vpHomogeneousMatrix &cMo, unsigned int width, unsigned int height,
102 const std::vector<vpColVector> &point_cloud, unsigned int stepX,
103 unsigned int stepY
104#if DEBUG_DISPLAY_DEPTH_DENSE
105 ,
106 vpImage<unsigned char> &debugImage, std::vector<std::vector<vpImagePoint> > &roiPts_vec
107#endif
108 , const vpImage<bool> *mask = NULL
109 );
110
111 void computeInteractionMatrixAndResidu(const vpHomogeneousMatrix &cMo, vpMatrix &L, vpColVector &error);
112
113 void computeVisibility();
114 void computeVisibilityDisplay();
115
116 void display(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
117 const vpColor &col, unsigned int thickness = 1, bool displayFullModel = false);
118 void display(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
119 const vpColor &col, unsigned int thickness = 1, bool displayFullModel = false);
120
121 void displayFeature(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
122 double scale = 0.05, unsigned int thickness = 1);
123 void displayFeature(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
124 double scale = 0.05, unsigned int thickness = 1);
125
126 std::vector<std::vector<double> > getModelForDisplay(unsigned int width, unsigned int height,
127 const vpHomogeneousMatrix &cMo,
128 const vpCameraParameters &cam,
129 bool displayFullModel = false);
130
131 inline unsigned int getNbFeatures() const { return (unsigned int)(m_pointCloudFace.size() / 3); }
132
133 inline bool isTracked() const { return m_isTrackedDepthDenseFace; }
134
135 inline bool isVisible() const { return m_polygon->isvisible; }
136
137 void setCameraParameters(const vpCameraParameters &camera);
138
139 void setScanLineVisibilityTest(bool v);
140
141 inline void setDepthDenseFilteringMaxDistance(double maxDistance)
142 {
143 m_depthDenseFilteringMaxDist = maxDistance;
144 }
145
146 inline void setDepthDenseFilteringMethod(int method) { m_depthDenseFilteringMethod = method; }
147
148 inline void setDepthDenseFilteringMinDistance(double minDistance)
149 {
150 m_depthDenseFilteringMinDist = minDistance;
151 }
152
153 inline void setDepthDenseFilteringOccupancyRatio(double occupancyRatio)
154 {
155 if (occupancyRatio < 0.0 || occupancyRatio > 1.0) {
156 std::cerr << "occupancyRatio < 0.0 || occupancyRatio > 1.0" << std::endl;
157 } else {
158 m_depthDenseFilteringOccupancyRatio = occupancyRatio;
159 }
160 }
161
162 inline void setTracked(bool tracked) { m_isTrackedDepthDenseFace = tracked; }
163
164private:
165 class PolygonLine
166 {
167 public:
169 vpPoint *m_p1;
171 vpPoint *m_p2;
173 vpMbtPolygon m_poly;
175 vpImagePoint m_imPt1;
177 vpImagePoint m_imPt2;
178
179 PolygonLine() : m_p1(NULL), m_p2(NULL), m_poly(), m_imPt1(), m_imPt2() {}
180
181 PolygonLine(const PolygonLine &polyLine)
182 : m_p1(NULL), m_p2(NULL), m_poly(polyLine.m_poly), m_imPt1(polyLine.m_imPt1), m_imPt2(polyLine.m_imPt2)
183 {
184 m_p1 = &m_poly.p[0];
185 m_p2 = &m_poly.p[1];
186 }
187
188 PolygonLine &operator=(PolygonLine other)
189 {
190 swap(*this, other);
191
192 return *this;
193 }
194
195 void swap(PolygonLine &first, PolygonLine &second)
196 {
197 using std::swap;
198 swap(first.m_p1, second.m_p1);
199 swap(first.m_p2, second.m_p2);
200 swap(first.m_poly, second.m_poly);
201 swap(first.m_imPt1, second.m_imPt1);
202 swap(first.m_imPt2, second.m_imPt2);
203 }
204 };
205
206protected:
219 std::vector<vpMbtDistanceLine *> m_listOfFaceLines;
224 std::vector<double> m_pointCloudFace;
226 std::vector<PolygonLine> m_polygonLines;
227
228protected:
229 void computeROI(const vpHomogeneousMatrix &cMo, unsigned int width, unsigned int height,
230 std::vector<vpImagePoint> &roiPts
231#if DEBUG_DISPLAY_DEPTH_DENSE
232 ,
233 std::vector<std::vector<vpImagePoint> > &roiPts_vec
234#endif
235 ,
236 double &distanceToFace);
237
238 bool samePoint(const vpPoint &P1, const vpPoint &P2) const;
239};
240#endif
Generic class defining intrinsic camera parameters.
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
Implementation of an homogeneous matrix and operations on such kind of matrices.
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition: vpImagePoint.h:88
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:154
double m_depthDenseFilteringMinDist
Minimum distance threshold.
vpMbHiddenFaces< vpMbtPolygon > * m_hiddenFace
Pointer to the list of faces.
bool m_isVisible
Visibility flag.
double m_distFarClip
Distance for near clipping.
std::vector< double > m_pointCloudFace
List of depth points inside the face.
vpPlane m_planeObject
Plane equation described in the object frame.
void setDepthDenseFilteringMethod(int method)
unsigned int getNbFeatures() const
void setTracked(bool tracked)
void setDepthDenseFilteringMinDistance(double minDistance)
vpMbtPolygon * m_polygon
Polygon defining the face.
bool m_useScanLine
Scan line visibility.
bool m_isTrackedDepthDenseFace
Flag to define if the face should be tracked or not.
double m_depthDenseFilteringMaxDist
Maximum distance threshold.
void setDepthDenseFilteringMaxDistance(double maxDistance)
std::vector< PolygonLine > m_polygonLines
Polygon lines used for scan-line visibility.
int m_depthDenseFilteringMethod
Method to use to consider or not the face.
unsigned int m_clippingFlag
Flags specifying which clipping to used.
std::vector< vpMbtDistanceLine * > m_listOfFaceLines
void setDepthDenseFilteringOccupancyRatio(double occupancyRatio)
vpCameraParameters m_cam
Camera intrinsic parameters.
double m_depthDenseFilteringOccupancyRatio
Ratio between available depth points and theoretical number of points.
double m_distNearClip
Distance for near clipping.
Implementation of a polygon of the model used by the model-based tracker.
Definition: vpMbtPolygon.h:67
bool isvisible
flag to specify whether the face is visible or not
Definition: vpMbtPolygon.h:73
This class defines the container for a plane geometrical structure.
Definition: vpPlane.h:59
Class that defines a 3D point in the object frame and allows forward projection of a 3D point in the ...
Definition: vpPoint.h:82
vpPoint * p
corners in the object frame
Definition: vpPolygon3D.h:81
Class for generating random numbers with uniform probability density.
Definition: vpUniRand.h:101