Point Cloud Library (PCL) 1.13.0
point_cloud_geometry_handlers.h
1/*
2 * Software License Agreement (BSD License)
3 *
4 * Point Cloud Library (PCL) - www.pointclouds.org
5 * Copyright (c) 2012-, Open Perception, Inc.
6 *
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * * Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer in the documentation and/or other materials provided
18 * with the distribution.
19 * * Neither the name of the copyright holder(s) nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 *
36 */
37
38#pragma once
39
40#if defined __GNUC__
41#pragma GCC system_header
42#endif
43
44// PCL includes
45#include <pcl/pcl_base.h> // for UNAVAILABLE
46#include <pcl/point_cloud.h>
47#include <pcl/common/io.h>
48// VTK includes
49#include <vtkSmartPointer.h>
50#include <vtkPoints.h>
51#include <vtkFloatArray.h>
52
53namespace pcl
54{
55 namespace visualization
56 {
57 /** \brief Base handler class for PointCloud geometry.
58 * \author Radu B. Rusu
59 * \ingroup visualization
60 */
61 template <typename PointT>
63 {
64 public:
68
69 using Ptr = shared_ptr<PointCloudGeometryHandler<PointT> >;
70 using ConstPtr = shared_ptr<const PointCloudGeometryHandler<PointT> >;
71
72 /** \brief Constructor. */
74 cloud_ (cloud), capable_ (false),
76 fields_ ()
77 {}
78
79 /** \brief Destructor. */
80 virtual ~PointCloudGeometryHandler() = default;
81
82 /** \brief Abstract getName method.
83 * \return the name of the class/object.
84 */
85 virtual std::string
86 getName () const = 0;
87
88 /** \brief Abstract getFieldName method. */
89 virtual std::string
90 getFieldName () const = 0;
91
92 /** \brief Checl if this handler is capable of handling the input data or not. */
93 inline bool
94 isCapable () const { return (capable_); }
95
96 /** \brief Obtain the actual point geometry for the input dataset in VTK format.
97 * \param[out] points the resultant geometry
98 */
99 virtual void
101
102 /** \brief Set the input cloud to be used.
103 * \param[in] cloud the input cloud to be used by the handler
104 */
105 void
107 {
108 cloud_ = cloud;
109 }
110
111 protected:
112 /** \brief A pointer to the input dataset. */
114
115 /** \brief True if this handler is capable of handling the input data, false
116 * otherwise.
117 */
119
120 /** \brief The index of the field holding the X data. */
122
123 /** \brief The index of the field holding the Y data. */
125
126 /** \brief The index of the field holding the Z data. */
128
129 /** \brief The list of fields available for this PointCloud. */
130 std::vector<pcl::PCLPointField> fields_;
131 };
132
133 //////////////////////////////////////////////////////////////////////////////////////
134 /** \brief XYZ handler class for PointCloud geometry. Given an input dataset, all XYZ
135 * data present in fields "x", "y", and "z" is extracted and displayed on screen.
136 * \author Radu B. Rusu
137 * \ingroup visualization
138 */
139 template <typename PointT>
141 {
142 public:
146
147 using Ptr = shared_ptr<PointCloudGeometryHandlerXYZ<PointT> >;
148 using ConstPtr = shared_ptr<const PointCloudGeometryHandlerXYZ<PointT> >;
149
150 /** \brief Constructor. */
152
153 /** \brief Class getName method. */
154 virtual std::string
155 getName () const { return ("PointCloudGeometryHandlerXYZ"); }
156
157 /** \brief Get the name of the field used. */
158 virtual std::string
159 getFieldName () const { return ("xyz"); }
160
161 /** \brief Obtain the actual point geometry for the input dataset in VTK format.
162 * \param[out] points the resultant geometry
163 */
164 virtual void
166
167 private:
168 // Members derived from the base class
175 };
176
177 //////////////////////////////////////////////////////////////////////////////////////
178 /** \brief Surface normal handler class for PointCloud geometry. Given an input
179 * dataset, all data present in fields "normal_x", "normal_y", and "normal_z" is
180 * extracted and displayed on screen as XYZ data.
181 * \author Radu B. Rusu
182 * \ingroup visualization
183 */
184 template <typename PointT>
186 {
187 public:
191
192 using Ptr = shared_ptr<PointCloudGeometryHandlerSurfaceNormal<PointT> >;
193 using ConstPtr = shared_ptr<const PointCloudGeometryHandlerSurfaceNormal<PointT> >;
194
195 /** \brief Constructor. */
197
198 /** \brief Class getName method. */
199 virtual std::string
200 getName () const { return ("PointCloudGeometryHandlerSurfaceNormal"); }
201
202 /** \brief Get the name of the field used. */
203 virtual std::string
204 getFieldName () const { return ("normal_xyz"); }
205
206 /** \brief Obtain the actual point geometry for the input dataset in VTK format.
207 * \param[out] points the resultant geometry
208 */
209 virtual void
211
212 private:
213 // Members derived from the base class
220 };
221
222 //////////////////////////////////////////////////////////////////////////////////////
223 /** \brief Custom handler class for PointCloud geometry. Given an input dataset and
224 * three user defined fields, all data present in them is extracted and displayed on
225 * screen as XYZ data.
226 * \author Radu B. Rusu
227 * \ingroup visualization
228 */
229 template <typename PointT>
231 {
232 public:
236
237 using Ptr = shared_ptr<PointCloudGeometryHandlerCustom<PointT> >;
238 using ConstPtr = shared_ptr<const PointCloudGeometryHandlerCustom<PointT> >;
239
240 /** \brief Constructor. */
242 const std::string &x_field_name,
243 const std::string &y_field_name,
244 const std::string &z_field_name)
246 {
247 field_x_idx_ = pcl::getFieldIndex<PointT> (x_field_name, fields_);
249 return;
250 field_y_idx_ = pcl::getFieldIndex<PointT> (y_field_name, fields_);
252 return;
253 field_z_idx_ = pcl::getFieldIndex<PointT> (z_field_name, fields_);
255 return;
256 field_name_ = x_field_name + y_field_name + z_field_name;
257 capable_ = true;
258 }
259
260 /** \brief Class getName method. */
261 virtual std::string
262 getName () const { return ("PointCloudGeometryHandlerCustom"); }
263
264 /** \brief Get the name of the field used. */
265 virtual std::string
266 getFieldName () const { return (field_name_); }
267
268 /** \brief Obtain the actual point geometry for the input dataset in VTK format.
269 * \param[out] points the resultant geometry
270 */
271 virtual void
273 {
274 if (!capable_)
275 return;
276
277 if (!points)
279 points->SetDataTypeToFloat ();
280 points->SetNumberOfPoints (cloud_->size ());
281
282 float data;
283 // Add all points
284 double p[3];
285 for (vtkIdType i = 0; i < static_cast<vtkIdType> (cloud_->size ()); ++i)
286 {
287 // Copy the value at the specified field
288 const std::uint8_t* pt_data = reinterpret_cast<const std::uint8_t*> (&(*cloud_)[i]);
289 memcpy (&data, pt_data + fields_[field_x_idx_].offset, sizeof (float));
290 p[0] = data;
291
292 memcpy (&data, pt_data + fields_[field_y_idx_].offset, sizeof (float));
293 p[1] = data;
294
295 memcpy (&data, pt_data + fields_[field_z_idx_].offset, sizeof (float));
296 p[2] = data;
297
298 points->SetPoint (i, p);
299 }
300 }
301
302 private:
303 // Members derived from the base class
310
311 /** \brief Name of the field used to create the geometry handler. */
312 std::string field_name_;
313 };
314
315 ///////////////////////////////////////////////////////////////////////////////////////
316 /** \brief Base handler class for PointCloud geometry.
317 * \author Radu B. Rusu
318 * \ingroup visualization
319 */
320 template <>
322 {
323 public:
327
328 using Ptr = shared_ptr<PointCloudGeometryHandler<PointCloud> >;
329 using ConstPtr = shared_ptr<const PointCloudGeometryHandler<PointCloud> >;
330
331 /** \brief Constructor. */
332 PointCloudGeometryHandler (const PointCloudConstPtr &cloud, const Eigen::Vector4f & = Eigen::Vector4f::Zero ())
333 : cloud_ (cloud)
334 , capable_ (false)
335 , field_x_idx_ (UNAVAILABLE)
336 , field_y_idx_ (UNAVAILABLE)
337 , field_z_idx_ (UNAVAILABLE)
338 , fields_ (cloud_->fields)
339 {
340 }
341
342 /** \brief Destructor. */
343 virtual ~PointCloudGeometryHandler() = default;
344
345 /** \brief Abstract getName method. */
346 virtual std::string
347 getName () const = 0;
348
349 /** \brief Abstract getFieldName method. */
350 virtual std::string
351 getFieldName () const = 0;
352
353 /** \brief Check if this handler is capable of handling the input data or not. */
354 inline bool
355 isCapable () const { return (capable_); }
356
357 /** \brief Obtain the actual point geometry for the input dataset in VTK format.
358 * \param[out] points the resultant geometry
359 */
360 virtual void
362
363 /** \brief Set the input cloud to be used.
364 * \param[in] cloud the input cloud to be used by the handler
365 */
366 void
368 {
369 cloud_ = cloud;
370 }
371
372 protected:
373 /** \brief A pointer to the input dataset. */
375
376 /** \brief True if this handler is capable of handling the input data, false
377 * otherwise.
378 */
380
381 /** \brief The index of the field holding the X data. */
383
384 /** \brief The index of the field holding the Y data. */
386
387 /** \brief The index of the field holding the Z data. */
389
390 /** \brief The list of fields available for this PointCloud. */
391 std::vector<pcl::PCLPointField> fields_;
392 };
393
394 //////////////////////////////////////////////////////////////////////////////////////
395 /** \brief XYZ handler class for PointCloud geometry. Given an input dataset, all XYZ
396 * data present in fields "x", "y", and "z" is extracted and displayed on screen.
397 * \author Radu B. Rusu
398 * \ingroup visualization
399 */
400 template <>
402 {
403 public:
407
408 using Ptr = shared_ptr<PointCloudGeometryHandlerXYZ<PointCloud> >;
409 using ConstPtr = shared_ptr<const PointCloudGeometryHandlerXYZ<PointCloud> >;
410
411 /** \brief Constructor. */
413
414 /** \brief Class getName method. */
415 virtual std::string
416 getName () const { return ("PointCloudGeometryHandlerXYZ"); }
417
418 /** \brief Get the name of the field used. */
419 virtual std::string
420 getFieldName () const { return ("xyz"); }
421 };
422
423 //////////////////////////////////////////////////////////////////////////////////////
424 /** \brief Surface normal handler class for PointCloud geometry. Given an input
425 * dataset, all data present in fields "normal_x", "normal_y", and "normal_z" is
426 * extracted and displayed on screen as XYZ data.
427 * \author Radu B. Rusu
428 * \ingroup visualization
429 */
430 template <>
432 {
433 public:
437
438 using Ptr = shared_ptr<PointCloudGeometryHandlerSurfaceNormal<PointCloud> >;
439 using ConstPtr = shared_ptr<const PointCloudGeometryHandlerSurfaceNormal<PointCloud> >;
440
441 /** \brief Constructor. */
443
444 /** \brief Class getName method. */
445 virtual std::string
446 getName () const { return ("PointCloudGeometryHandlerSurfaceNormal"); }
447
448 /** \brief Get the name of the field used. */
449 virtual std::string
450 getFieldName () const { return ("normal_xyz"); }
451 };
452
453 //////////////////////////////////////////////////////////////////////////////////////
454 /** \brief Custom handler class for PointCloud geometry. Given an input dataset and
455 * three user defined fields, all data present in them is extracted and displayed on
456 * screen as XYZ data.
457 * \author Radu B. Rusu
458 * \ingroup visualization
459 */
460 template <>
462 {
463 public:
467
468 /** \brief Constructor. */
470 const std::string &x_field_name,
471 const std::string &y_field_name,
472 const std::string &z_field_name);
473
474 /** \brief Class getName method. */
475 virtual std::string
476 getName () const { return ("PointCloudGeometryHandlerCustom"); }
477
478 /** \brief Get the name of the field used. */
479 virtual std::string
480 getFieldName () const { return (field_name_); }
481
482 private:
483 /** \brief Name of the field used to create the geometry handler. */
484 std::string field_name_;
485 };
486 }
487}
488
489#ifdef PCL_NO_PRECOMPILE
490#include <pcl/visualization/impl/point_cloud_geometry_handlers.hpp>
491#endif
PointCloud represents the base class in PCL for storing collections of 3D points.
Definition: point_cloud.h:173
shared_ptr< PointCloud< PointT > > Ptr
Definition: point_cloud.h:413
shared_ptr< const PointCloud< PointT > > ConstPtr
Definition: point_cloud.h:414
virtual std::string getName() const =0
Abstract getName method.
void setInputCloud(const PointCloudConstPtr &cloud)
Set the input cloud to be used.
shared_ptr< const PointCloudGeometryHandler< PointCloud > > ConstPtr
virtual void getGeometry(vtkSmartPointer< vtkPoints > &points) const
Obtain the actual point geometry for the input dataset in VTK format.
bool isCapable() const
Check if this handler is capable of handling the input data or not.
bool capable_
True if this handler is capable of handling the input data, false otherwise.
std::vector< pcl::PCLPointField > fields_
The list of fields available for this PointCloud.
PointCloudGeometryHandler(const PointCloudConstPtr &cloud, const Eigen::Vector4f &=Eigen::Vector4f::Zero())
Constructor.
virtual std::string getFieldName() const =0
Abstract getFieldName method.
virtual std::string getFieldName() const
Get the name of the field used.
PointCloudGeometryHandlerCustom(const PointCloudConstPtr &cloud, const std::string &x_field_name, const std::string &y_field_name, const std::string &z_field_name)
Constructor.
virtual std::string getFieldName() const
Get the name of the field used.
virtual std::string getName() const
Class getName method.
virtual void getGeometry(vtkSmartPointer< vtkPoints > &points) const
Obtain the actual point geometry for the input dataset in VTK format.
PointCloudGeometryHandlerCustom(const PointCloudConstPtr &cloud, const std::string &x_field_name, const std::string &y_field_name, const std::string &z_field_name)
Constructor.
Base handler class for PointCloud geometry.
std::vector< pcl::PCLPointField > fields_
The list of fields available for this PointCloud.
index_t field_y_idx_
The index of the field holding the Y data.
virtual std::string getName() const =0
Abstract getName method.
bool isCapable() const
Checl if this handler is capable of handling the input data or not.
index_t field_z_idx_
The index of the field holding the Z data.
shared_ptr< const PointCloudGeometryHandler< PointT > > ConstPtr
PointCloudGeometryHandler(const PointCloudConstPtr &cloud)
Constructor.
bool capable_
True if this handler is capable of handling the input data, false otherwise.
void setInputCloud(const PointCloudConstPtr &cloud)
Set the input cloud to be used.
PointCloudConstPtr cloud_
A pointer to the input dataset.
virtual std::string getFieldName() const =0
Abstract getFieldName method.
virtual void getGeometry(vtkSmartPointer< vtkPoints > &points) const =0
Obtain the actual point geometry for the input dataset in VTK format.
virtual ~PointCloudGeometryHandler()=default
Destructor.
shared_ptr< PointCloudGeometryHandler< PointT > > Ptr
index_t field_x_idx_
The index of the field holding the X data.
PointCloudGeometryHandlerSurfaceNormal(const PointCloudConstPtr &cloud)
Constructor.
Surface normal handler class for PointCloud geometry.
virtual std::string getFieldName() const
Get the name of the field used.
virtual void getGeometry(vtkSmartPointer< vtkPoints > &points) const
Obtain the actual point geometry for the input dataset in VTK format.
PointCloudGeometryHandlerSurfaceNormal(const PointCloudConstPtr &cloud)
Constructor.
virtual std::string getName() const
Class getName method.
virtual std::string getFieldName() const
Get the name of the field used.
PointCloudGeometryHandlerXYZ(const PointCloudConstPtr &cloud)
Constructor.
virtual void getGeometry(vtkSmartPointer< vtkPoints > &points) const
Obtain the actual point geometry for the input dataset in VTK format.
PointCloudGeometryHandlerXYZ(const PointCloudConstPtr &cloud)
Constructor.
virtual std::string getFieldName() const
Get the name of the field used.
virtual std::string getName() const
Class getName method.
static constexpr index_t UNAVAILABLE
Definition: pcl_base.h:62
detail::int_type_t< detail::index_type_size, detail::index_type_signed > index_t
Type used for an index in PCL.
Definition: types.h:112
#define PCL_EXPORTS
Definition: pcl_macros.h:323
A point structure representing Euclidean xyz coordinates, and the RGB color.