Point Cloud Library (PCL)  1.11.1-dev
point_types.hpp
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2010, Willow Garage, Inc.
6  * Copyright (c) 2012-, Open Perception, Inc.
7  *
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * * Redistributions of source code must retain the above copyright
15  * notice, this list of conditions and the following disclaimer.
16  * * Redistributions in binary form must reproduce the above
17  * copyright notice, this list of conditions and the following
18  * disclaimer in the documentation and/or other materials provided
19  * with the distribution.
20  * * Neither the name of the copyright holder(s) nor the names of its
21  * contributors may be used to endorse or promote products derived
22  * from this software without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
27  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
28  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35  * POSSIBILITY OF SUCH DAMAGE.
36  *
37  */
38 
39 #pragma once
40 
41 #include <pcl/memory.h> // for PCL_MAKE_ALIGNED_OPERATOR_NEW
42 #include <pcl/pcl_macros.h> // for PCL_EXPORTS
43 #include <pcl/PCLPointField.h> // for PCLPointField
44 #include <pcl/point_types.h> // implementee
45 #include <pcl/register_point_struct.h> // for POINT_CLOUD_REGISTER_POINT_STRUCT, POINT_CLOUD_REGISTER_POINT_WRAPPER
46 
47 #include <boost/mpl/and.hpp> // for boost::mpl::and_
48 #include <boost/mpl/bool.hpp> // for boost::mpl::bool_
49 #include <boost/mpl/contains.hpp> // for boost::mpl::contains
50 #include <boost/mpl/fold.hpp> // for boost::mpl::fold
51 #include <boost/mpl/or.hpp> // for boost::mpl::or_
52 #include <boost/mpl/placeholders.hpp> // for boost::mpl::_1, boost::mpl::_2
53 #include <boost/mpl/vector.hpp> // for boost::mpl::vector
54 
55 #include <Eigen/Core> // for MatrixMap
56 
57 #include <algorithm> // for copy_n, fill_n
58 #include <cstdint> // for uint8_t, uint32_t
59 #include <ostream> // for ostream, operator<<
60 #include <type_traits> // for enable_if_t
61 
62 // Define all PCL point types
63 #define PCL_POINT_TYPES \
64  (pcl::PointXYZ) \
65  (pcl::PointXYZI) \
66  (pcl::PointXYZL) \
67  (pcl::Label) \
68  (pcl::PointXYZRGBA) \
69  (pcl::PointXYZRGB) \
70  (pcl::PointXYZRGBL) \
71  (pcl::PointXYZHSV) \
72  (pcl::PointXY) \
73  (pcl::InterestPoint) \
74  (pcl::Axis) \
75  (pcl::Normal) \
76  (pcl::PointNormal) \
77  (pcl::PointXYZRGBNormal) \
78  (pcl::PointXYZINormal) \
79  (pcl::PointXYZLNormal) \
80  (pcl::PointWithRange) \
81  (pcl::PointWithViewpoint) \
82  (pcl::MomentInvariants) \
83  (pcl::PrincipalRadiiRSD) \
84  (pcl::Boundary) \
85  (pcl::PrincipalCurvatures) \
86  (pcl::PFHSignature125) \
87  (pcl::PFHRGBSignature250) \
88  (pcl::PPFSignature) \
89  (pcl::CPPFSignature) \
90  (pcl::PPFRGBSignature) \
91  (pcl::NormalBasedSignature12) \
92  (pcl::FPFHSignature33) \
93  (pcl::VFHSignature308) \
94  (pcl::GASDSignature512) \
95  (pcl::GASDSignature984) \
96  (pcl::GASDSignature7992) \
97  (pcl::GRSDSignature21) \
98  (pcl::ESFSignature640) \
99  (pcl::BRISKSignature512) \
100  (pcl::Narf36) \
101  (pcl::IntensityGradient) \
102  (pcl::PointWithScale) \
103  (pcl::PointSurfel) \
104  (pcl::ShapeContext1980) \
105  (pcl::UniqueShapeContext1960) \
106  (pcl::SHOT352) \
107  (pcl::SHOT1344) \
108  (pcl::PointUV) \
109  (pcl::ReferenceFrame) \
110  (pcl::PointDEM)
111 
112 // Define all point types that include RGB data
113 #define PCL_RGB_POINT_TYPES \
114  (pcl::PointXYZRGBA) \
115  (pcl::PointXYZRGB) \
116  (pcl::PointXYZRGBL) \
117  (pcl::PointXYZRGBNormal) \
118  (pcl::PointSurfel) \
119 
120 // Define all point types that include XYZ data
121 #define PCL_XYZ_POINT_TYPES \
122  (pcl::PointXYZ) \
123  (pcl::PointXYZI) \
124  (pcl::PointXYZL) \
125  (pcl::PointXYZRGBA) \
126  (pcl::PointXYZRGB) \
127  (pcl::PointXYZRGBL) \
128  (pcl::PointXYZHSV) \
129  (pcl::InterestPoint) \
130  (pcl::PointNormal) \
131  (pcl::PointXYZRGBNormal) \
132  (pcl::PointXYZINormal) \
133  (pcl::PointXYZLNormal) \
134  (pcl::PointWithRange) \
135  (pcl::PointWithViewpoint) \
136  (pcl::PointWithScale) \
137  (pcl::PointSurfel) \
138  (pcl::PointDEM)
139 
140 // Define all point types with XYZ and label
141 #define PCL_XYZL_POINT_TYPES \
142  (pcl::PointXYZL) \
143  (pcl::PointXYZRGBL) \
144  (pcl::PointXYZLNormal)
145 
146 // Define all point types that include normal[3] data
147 #define PCL_NORMAL_POINT_TYPES \
148  (pcl::Normal) \
149  (pcl::PointNormal) \
150  (pcl::PointXYZRGBNormal) \
151  (pcl::PointXYZINormal) \
152  (pcl::PointXYZLNormal) \
153  (pcl::PointSurfel)
154 
155 // Define all point types that represent features
156 #define PCL_FEATURE_POINT_TYPES \
157  (pcl::PFHSignature125) \
158  (pcl::PFHRGBSignature250) \
159  (pcl::PPFSignature) \
160  (pcl::CPPFSignature) \
161  (pcl::PPFRGBSignature) \
162  (pcl::NormalBasedSignature12) \
163  (pcl::FPFHSignature33) \
164  (pcl::VFHSignature308) \
165  (pcl::GASDSignature512) \
166  (pcl::GASDSignature984) \
167  (pcl::GASDSignature7992) \
168  (pcl::GRSDSignature21) \
169  (pcl::ESFSignature640) \
170  (pcl::BRISKSignature512) \
171  (pcl::Narf36)
172 
173 namespace pcl
174 {
175 
176  using Array3fMap = Eigen::Map<Eigen::Array3f>;
177  using Array3fMapConst = const Eigen::Map<const Eigen::Array3f>;
178  using Array4fMap = Eigen::Map<Eigen::Array4f, Eigen::Aligned>;
179  using Array4fMapConst = const Eigen::Map<const Eigen::Array4f, Eigen::Aligned>;
180  using Vector3fMap = Eigen::Map<Eigen::Vector3f>;
181  using Vector3fMapConst = const Eigen::Map<const Eigen::Vector3f>;
182  using Vector4fMap = Eigen::Map<Eigen::Vector4f, Eigen::Aligned>;
183  using Vector4fMapConst = const Eigen::Map<const Eigen::Vector4f, Eigen::Aligned>;
184 
185  using Vector3c = Eigen::Matrix<std::uint8_t, 3, 1>;
186  using Vector3cMap = Eigen::Map<Vector3c>;
187  using Vector3cMapConst = const Eigen::Map<const Vector3c>;
188  using Vector4c = Eigen::Matrix<std::uint8_t, 4, 1>;
189  using Vector4cMap = Eigen::Map<Vector4c, Eigen::Aligned>;
190  using Vector4cMapConst = const Eigen::Map<const Vector4c, Eigen::Aligned>;
191 
192 #define PCL_ADD_UNION_POINT4D \
193  union EIGEN_ALIGN16 { \
194  float data[4]; \
195  struct { \
196  float x; \
197  float y; \
198  float z; \
199  }; \
200  };
201 
202 #define PCL_ADD_EIGEN_MAPS_POINT4D \
203  inline pcl::Vector3fMap getVector3fMap () { return (pcl::Vector3fMap (data)); } \
204  inline pcl::Vector3fMapConst getVector3fMap () const { return (pcl::Vector3fMapConst (data)); } \
205  inline pcl::Vector4fMap getVector4fMap () { return (pcl::Vector4fMap (data)); } \
206  inline pcl::Vector4fMapConst getVector4fMap () const { return (pcl::Vector4fMapConst (data)); } \
207  inline pcl::Array3fMap getArray3fMap () { return (pcl::Array3fMap (data)); } \
208  inline pcl::Array3fMapConst getArray3fMap () const { return (pcl::Array3fMapConst (data)); } \
209  inline pcl::Array4fMap getArray4fMap () { return (pcl::Array4fMap (data)); } \
210  inline pcl::Array4fMapConst getArray4fMap () const { return (pcl::Array4fMapConst (data)); }
211 
212 #define PCL_ADD_POINT4D \
213  PCL_ADD_UNION_POINT4D \
214  PCL_ADD_EIGEN_MAPS_POINT4D
215 
216 #define PCL_ADD_UNION_NORMAL4D \
217  union EIGEN_ALIGN16 { \
218  float data_n[4]; \
219  float normal[3]; \
220  struct { \
221  float normal_x; \
222  float normal_y; \
223  float normal_z; \
224  }; \
225  };
226 
227 #define PCL_ADD_EIGEN_MAPS_NORMAL4D \
228  inline pcl::Vector3fMap getNormalVector3fMap () { return (pcl::Vector3fMap (data_n)); } \
229  inline pcl::Vector3fMapConst getNormalVector3fMap () const { return (pcl::Vector3fMapConst (data_n)); } \
230  inline pcl::Vector4fMap getNormalVector4fMap () { return (pcl::Vector4fMap (data_n)); } \
231  inline pcl::Vector4fMapConst getNormalVector4fMap () const { return (pcl::Vector4fMapConst (data_n)); }
232 
233 #define PCL_ADD_NORMAL4D \
234  PCL_ADD_UNION_NORMAL4D \
235  PCL_ADD_EIGEN_MAPS_NORMAL4D
236 
237 #define PCL_ADD_UNION_RGB \
238  union \
239  { \
240  union \
241  { \
242  struct \
243  { \
244  std::uint8_t b; \
245  std::uint8_t g; \
246  std::uint8_t r; \
247  std::uint8_t a; \
248  }; \
249  float rgb; \
250  }; \
251  std::uint32_t rgba; \
252  };
253 
254 #define PCL_ADD_EIGEN_MAPS_RGB \
255  inline Eigen::Vector3i getRGBVector3i () { return (Eigen::Vector3i (r, g, b)); } \
256  inline const Eigen::Vector3i getRGBVector3i () const { return (Eigen::Vector3i (r, g, b)); } \
257  inline Eigen::Vector4i getRGBVector4i () { return (Eigen::Vector4i (r, g, b, a)); } \
258  inline const Eigen::Vector4i getRGBVector4i () const { return (Eigen::Vector4i (r, g, b, a)); } \
259  inline Eigen::Vector4i getRGBAVector4i () { return (Eigen::Vector4i (r, g, b, a)); } \
260  inline const Eigen::Vector4i getRGBAVector4i () const { return (Eigen::Vector4i (r, g, b, a)); } \
261  inline pcl::Vector3cMap getBGRVector3cMap () { return (pcl::Vector3cMap (reinterpret_cast<std::uint8_t*> (&rgba))); } \
262  inline pcl::Vector3cMapConst getBGRVector3cMap () const { return (pcl::Vector3cMapConst (reinterpret_cast<const std::uint8_t*> (&rgba))); } \
263  inline pcl::Vector4cMap getBGRAVector4cMap () { return (pcl::Vector4cMap (reinterpret_cast<std::uint8_t*> (&rgba))); } \
264  inline pcl::Vector4cMapConst getBGRAVector4cMap () const { return (pcl::Vector4cMapConst (reinterpret_cast<const std::uint8_t*> (&rgba))); }
265 
266 #define PCL_ADD_RGB \
267  PCL_ADD_UNION_RGB \
268  PCL_ADD_EIGEN_MAPS_RGB
269 
270 #define PCL_ADD_INTENSITY \
271  struct \
272  { \
273  float intensity; \
274  }; \
275 
276 #define PCL_ADD_INTENSITY_8U \
277  struct \
278  { \
279  std::uint8_t intensity; \
280  }; \
281 
282 #define PCL_ADD_INTENSITY_32U \
283  struct \
284  { \
285  std::uint32_t intensity; \
286  }; \
287 
288 
289  struct _PointXYZ
290  {
291  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
292 
294  };
295 
296  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZ& p);
297  /** \brief A point structure representing Euclidean xyz coordinates. (SSE friendly)
298  * \ingroup common
299  */
300  struct EIGEN_ALIGN16 PointXYZ : public _PointXYZ
301  {
302  inline PointXYZ (const _PointXYZ &p): PointXYZ(p.x, p.y, p.z) {}
303 
304  inline PointXYZ (): PointXYZ(0.f, 0.f, 0.f) {}
305 
306  inline PointXYZ (float _x, float _y, float _z)
307  {
308  x = _x; y = _y; z = _z;
309  data[3] = 1.0f;
310  }
311 
312  friend std::ostream& operator << (std::ostream& os, const PointXYZ& p);
314  };
315 
316 
317 #ifdef RGB
318 #undef RGB
319 #endif
320  struct _RGB
321  {
323  };
324 
325  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const RGB& p);
326  /** \brief A structure representing RGB color information.
327  *
328  * The RGBA information is available either as separate r, g, b, or as a
329  * packed std::uint32_t rgba value. To pack it, use:
330  *
331  * \code
332  * int rgb = ((int)r) << 16 | ((int)g) << 8 | ((int)b);
333  * \endcode
334  *
335  * To unpack it use:
336  *
337  * \code
338  * int rgb = ...;
339  * std::uint8_t r = (rgb >> 16) & 0x0000ff;
340  * std::uint8_t g = (rgb >> 8) & 0x0000ff;
341  * std::uint8_t b = (rgb) & 0x0000ff;
342  * \endcode
343  *
344  */
345  struct RGB: public _RGB
346  {
347  inline RGB (const _RGB &p)
348  {
349  rgba = p.rgba;
350  }
351 
352  inline RGB (): RGB(0, 0, 0) {}
353 
354  inline RGB (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
355  {
356  r = _r; g = _g; b = _b;
357  a = 255;
358  }
359 
360  friend std::ostream& operator << (std::ostream& os, const RGB& p);
361  };
362 
363  struct _Intensity
364  {
366  };
367 
368  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Intensity& p);
369  /** \brief A point structure representing the grayscale intensity in single-channel images.
370  * Intensity is represented as a float value.
371  * \ingroup common
372  */
373  struct Intensity: public _Intensity
374  {
375  inline Intensity (const _Intensity &p)
376  {
377  intensity = p.intensity;
378  }
379 
380  inline Intensity (float _intensity = 0.f)
381  {
382  intensity = _intensity;
383  }
384 
385  friend std::ostream& operator << (std::ostream& os, const Intensity& p);
386  };
387 
388 
390  {
392  };
393 
394  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Intensity8u& p);
395  /** \brief A point structure representing the grayscale intensity in single-channel images.
396  * Intensity is represented as a std::uint8_t value.
397  * \ingroup common
398  */
399  struct Intensity8u: public _Intensity8u
400  {
401  inline Intensity8u (const _Intensity8u &p)
402  {
403  intensity = p.intensity;
404  }
405 
406  inline Intensity8u (std::uint8_t _intensity = 0)
407  {
408  intensity = _intensity;
409  }
410 
411 #if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 1101
412  operator unsigned char() const
413  {
414  return intensity;
415  }
416 #endif
417 
418  friend std::ostream& operator << (std::ostream& os, const Intensity8u& p);
419  };
420 
422  {
424  };
425 
426  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Intensity32u& p);
427  /** \brief A point structure representing the grayscale intensity in single-channel images.
428  * Intensity is represented as a std::uint32_t value.
429  * \ingroup common
430  */
432  {
433  inline Intensity32u (const _Intensity32u &p)
434  {
435  intensity = p.intensity;
436  }
437 
438  inline Intensity32u (std::uint32_t _intensity = 0)
439  {
440  intensity = _intensity;
441  }
442 
443  friend std::ostream& operator << (std::ostream& os, const Intensity32u& p);
444  };
445 
446  /** \brief A point structure representing Euclidean xyz coordinates, and the intensity value.
447  * \ingroup common
448  */
449  struct EIGEN_ALIGN16 _PointXYZI
450  {
451  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
452  union
453  {
454  struct
455  {
456  float intensity;
457  };
458  float data_c[4];
459  };
461  };
462 
463  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZI& p);
464  struct PointXYZI : public _PointXYZI
465  {
466  inline PointXYZI (const _PointXYZI &p)
467  {
468  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
469  intensity = p.intensity;
470  }
471 
472  inline PointXYZI (float _intensity = 0.f): PointXYZI(0.f, 0.f, 0.f, _intensity) {}
473 
474  inline PointXYZI (float _x, float _y, float _z, float _intensity = 0.f)
475  {
476  x = _x; y = _y; z = _z;
477  data[3] = 1.0f;
478  intensity = _intensity;
479  }
480 
481  friend std::ostream& operator << (std::ostream& os, const PointXYZI& p);
482  };
483 
484 
485  struct EIGEN_ALIGN16 _PointXYZL
486  {
487  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
488  std::uint32_t label;
490  };
491 
492  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZL& p);
493  struct PointXYZL : public _PointXYZL
494  {
495  inline PointXYZL (const _PointXYZL &p)
496  {
497  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
498  label = p.label;
499  }
500 
501  inline PointXYZL (std::uint32_t _label = 0): PointXYZL(0.f, 0.f, 0.f, _label) {}
502 
503  inline PointXYZL (float _x, float _y, float _z, std::uint32_t _label = 0)
504  {
505  x = _x; y = _y; z = _z;
506  data[3] = 1.0f;
507  label = _label;
508  }
509 
510  friend std::ostream& operator << (std::ostream& os, const PointXYZL& p);
511  };
512 
513 
514  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Label& p);
515  struct Label
516  {
517  std::uint32_t label = 0;
518 
519  Label (std::uint32_t _label = 0): label(_label) {}
520 
521  friend std::ostream& operator << (std::ostream& os, const Label& p);
522  };
523 
524 
525  struct EIGEN_ALIGN16 _PointXYZRGBA
526  {
527  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
530  };
531 
532  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZRGBA& p);
533  /** \brief A point structure representing Euclidean xyz coordinates, and the RGBA color.
534  *
535  * The RGBA information is available either as separate r, g, b, or as a
536  * packed std::uint32_t rgba value. To pack it, use:
537  *
538  * \code
539  * int rgb = ((int)r) << 16 | ((int)g) << 8 | ((int)b);
540  * \endcode
541  *
542  * To unpack it use:
543  *
544  * \code
545  * int rgb = ...;
546  * std::uint8_t r = (rgb >> 16) & 0x0000ff;
547  * std::uint8_t g = (rgb >> 8) & 0x0000ff;
548  * std::uint8_t b = (rgb) & 0x0000ff;
549  * \endcode
550  *
551  * \ingroup common
552  */
553  struct EIGEN_ALIGN16 PointXYZRGBA : public _PointXYZRGBA
554  {
555  inline PointXYZRGBA (const _PointXYZRGBA &p)
556  {
557  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
558  rgba = p.rgba;
559  }
560 
561  inline PointXYZRGBA (): PointXYZRGBA (0, 0, 0, 0) {}
562 
563  inline PointXYZRGBA (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a):
564  PointXYZRGBA (0.f, 0.f, 0.f, _r, _g, _b, _a) {}
565 
566  inline PointXYZRGBA (float _x, float _y, float _z):
567  PointXYZRGBA (_x, _y, _z, 0, 0, 0, 0) {}
568 
569  inline PointXYZRGBA (float _x, float _y, float _z, std::uint8_t _r,
570  std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
571  {
572  x = _x; y = _y; z = _z;
573  data[3] = 1.0f;
574  r = _r; g = _g; b = _b; a = _a;
575  }
576 
577  friend std::ostream& operator << (std::ostream& os, const PointXYZRGBA& p);
578  };
579 
580 
581  struct EIGEN_ALIGN16 _PointXYZRGB
582  {
583  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
586  };
587 
588  struct EIGEN_ALIGN16 _PointXYZRGBL
589  {
590  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
592  std::uint32_t label;
594  };
595 
596  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZRGB& p);
597  /** \brief A point structure representing Euclidean xyz coordinates, and the RGB color.
598  *
599  * Due to historical reasons (PCL was first developed as a ROS package), the
600  * RGB information is packed into an integer and casted to a float. This is
601  * something we wish to remove in the near future, but in the meantime, the
602  * following code snippet should help you pack and unpack RGB colors in your
603  * PointXYZRGB structure:
604  *
605  * \code
606  * // pack r/g/b into rgb
607  * std::uint8_t r = 255, g = 0, b = 0; // Example: Red color
608  * std::uint32_t rgb = ((std::uint32_t)r << 16 | (std::uint32_t)g << 8 | (std::uint32_t)b);
609  * p.rgb = *reinterpret_cast<float*>(&rgb);
610  * \endcode
611  *
612  * To unpack the data into separate values, use:
613  *
614  * \code
615  * PointXYZRGB p;
616  * // unpack rgb into r/g/b
617  * std::uint32_t rgb = *reinterpret_cast<int*>(&p.rgb);
618  * std::uint8_t r = (rgb >> 16) & 0x0000ff;
619  * std::uint8_t g = (rgb >> 8) & 0x0000ff;
620  * std::uint8_t b = (rgb) & 0x0000ff;
621  * \endcode
622  *
623  *
624  * Alternatively, from 1.1.0 onwards, you can use p.r, p.g, and p.b directly.
625  *
626  * \ingroup common
627  */
628  struct EIGEN_ALIGN16 PointXYZRGB : public _PointXYZRGB
629  {
630  inline PointXYZRGB (const _PointXYZRGB &p)
631  {
632  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
633  rgb = p.rgb;
634  }
635 
636  inline PointXYZRGB (): PointXYZRGB (0.f, 0.f, 0.f) {}
637 
638  inline PointXYZRGB (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
639  PointXYZRGB (0.f, 0.f, 0.f, _r, _g, _b) {}
640 
641  inline PointXYZRGB (float _x, float _y, float _z):
642  PointXYZRGB (_x, _y, _z, 0, 0, 0) {}
643 
644  inline PointXYZRGB (float _x, float _y, float _z,
645  std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
646  {
647  x = _x; y = _y; z = _z;
648  data[3] = 1.0f;
649  r = _r; g = _g; b = _b;
650  a = 255;
651  }
652 
653  friend std::ostream& operator << (std::ostream& os, const PointXYZRGB& p);
655  };
656 
657 
658  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZRGBL& p);
659  struct EIGEN_ALIGN16 PointXYZRGBL : public _PointXYZRGBL
660  {
661  inline PointXYZRGBL (const _PointXYZRGBL &p)
662  {
663  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
664  rgba = p.rgba;
665  label = p.label;
666  }
667 
668  inline PointXYZRGBL (std::uint32_t _label = 0):
669  PointXYZRGBL (0.f, 0.f, 0.f, 0, 0, 0, _label) {}
670 
671  inline PointXYZRGBL (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
672  PointXYZRGBL (0.f, 0.f, 0.f, _r, _g, _b) {}
673 
674  inline PointXYZRGBL (float _x, float _y, float _z):
675  PointXYZRGBL (_x, _y, _z, 0, 0, 0) {}
676 
677  inline PointXYZRGBL (float _x, float _y, float _z,
678  std::uint8_t _r, std::uint8_t _g, std::uint8_t _b,
679  std::uint32_t _label = 0)
680  {
681  x = _x; y = _y; z = _z;
682  data[3] = 1.0f;
683  r = _r; g = _g; b = _b;
684  a = 255;
685  label = _label;
686  }
687 
688  friend std::ostream& operator << (std::ostream& os, const PointXYZRGBL& p);
690  };
691 
692 
693  struct EIGEN_ALIGN16 _PointXYZHSV
694  {
695  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
696  union
697  {
698  struct
699  {
700  float h;
701  float s;
702  float v;
703  };
704  float data_c[4];
705  };
707  };
708 
709  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZHSV& p);
710  struct EIGEN_ALIGN16 PointXYZHSV : public _PointXYZHSV
711  {
712  inline PointXYZHSV (const _PointXYZHSV &p)
713  {
714  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
715  h = p.h; s = p.s; v = p.v;
716  }
717 
718  inline PointXYZHSV (): PointXYZHSV (0.f, 0.f, 0.f) {}
719 
720  // @TODO: Use strong types??
721  // This is a dangerous type, doesn't behave like others
722  inline PointXYZHSV (float _h, float _s, float _v):
723  PointXYZHSV (0.f, 0.f, 0.f, _h, _s, _v) {}
724 
725  inline PointXYZHSV (float _x, float _y, float _z,
726  float _h, float _s, float _v)
727  {
728  x = _x; y = _y; z = _z;
729  data[3] = 1.0f;
730  h = _h; s = _s; v = _v;
731  data_c[3] = 0;
732  }
733 
734  friend std::ostream& operator << (std::ostream& os, const PointXYZHSV& p);
736  };
737 
738 
739 
740  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXY& p);
741  /** \brief A 2D point structure representing Euclidean xy coordinates.
742  * \ingroup common
743  */
744  struct PointXY
745  {
746  float x = 0.f;
747  float y = 0.f;
748 
749  inline PointXY() = default;
750 
751  inline PointXY(float _x, float _y): x(_x), y(_y) {}
752 
753  friend std::ostream& operator << (std::ostream& os, const PointXY& p);
754  };
755 
756  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointUV& p);
757  /** \brief A 2D point structure representing pixel image coordinates.
758  * \note We use float to be able to represent subpixels.
759  * \ingroup common
760  */
761  struct PointUV
762  {
763  float u = 0.f;
764  float v = 0.f;
765 
766  inline PointUV() = default;
767 
768  inline PointUV(float _u, float _v): u(_u), v(_v) {}
769 
770  friend std::ostream& operator << (std::ostream& os, const PointUV& p);
771  };
772 
773  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const InterestPoint& p);
774  /** \brief A point structure representing an interest point with Euclidean xyz coordinates, and an interest value.
775  * \ingroup common
776  */
777  // @TODO: inheritance trick like on other PointTypes
778  struct EIGEN_ALIGN16 InterestPoint
779  {
780  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
781  union
782  {
783  struct
784  {
785  float strength;
786  };
787  float data_c[4];
788  };
790 
791  friend std::ostream& operator << (std::ostream& os, const InterestPoint& p);
792  };
793 
794  struct EIGEN_ALIGN16 _Normal
795  {
796  PCL_ADD_NORMAL4D; // This adds the member normal[3] which can also be accessed using the point (which is float[4])
797  union
798  {
799  struct
800  {
801  float curvature;
802  };
803  float data_c[4];
804  };
806  };
807 
808  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Normal& p);
809  /** \brief A point structure representing normal coordinates and the surface curvature estimate. (SSE friendly)
810  * \ingroup common
811  */
812  struct Normal : public _Normal
813  {
814  inline Normal (const _Normal &p)
815  {
816  normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z;
817  data_n[3] = 0.0f;
818  curvature = p.curvature;
819  }
820 
821  inline Normal (float _curvature = 0.f): Normal (0.f, 0.f, 0.f, _curvature) {}
822 
823  inline Normal (float n_x, float n_y, float n_z, float _curvature = 0.f)
824  {
825  normal_x = n_x; normal_y = n_y; normal_z = n_z;
826  data_n[3] = 0.0f;
827  curvature = _curvature;
828  }
829 
830  friend std::ostream& operator << (std::ostream& os, const Normal& p);
832  };
833 
834 
835  struct EIGEN_ALIGN16 _Axis
836  {
839  };
840 
841  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Axis& p);
842  /** \brief A point structure representing an Axis using its normal coordinates. (SSE friendly)
843  * \ingroup common
844  */
845  struct EIGEN_ALIGN16 Axis : public _Axis
846  {
847  inline Axis (const _Axis &p)
848  {
849  normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z;
850  data_n[3] = 0.0f;
851  }
852 
853  inline Axis (): Axis (0.f, 0.f, 0.f) {}
854 
855  inline Axis (float n_x, float n_y, float n_z)
856  {
857  normal_x = n_x; normal_y = n_y; normal_z = n_z;
858  data_n[3] = 0.0f;
859  }
860 
861  friend std::ostream& operator << (std::ostream& os, const Axis& p);
863  };
864 
865 
866  struct EIGEN_ALIGN16 _PointNormal
867  {
868  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
869  PCL_ADD_NORMAL4D; // This adds the member normal[3] which can also be accessed using the point (which is float[4])
870  union
871  {
872  struct
873  {
874  float curvature;
875  };
876  float data_c[4];
877  };
879  };
880 
881  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointNormal& p);
882  /** \brief A point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate. (SSE friendly)
883  * \ingroup common
884  */
885  struct PointNormal : public _PointNormal
886  {
887  inline PointNormal (const _PointNormal &p)
888  {
889  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
890  normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z; data_n[3] = 0.0f;
891  curvature = p.curvature;
892  }
893 
894  inline PointNormal (float _curvature = 0.f): PointNormal (0.f, 0.f, 0.f, 0.f, 0.f, 0.f, _curvature) {}
895 
896  inline PointNormal (float _x, float _y, float _z):
897  PointNormal (_x, _y, _z, 0.f, 0.f, 0.f, 0.f) {}
898 
899  inline PointNormal (float _x, float _y, float _z, float n_x, float n_y, float n_z, float _curvature = 0.f)
900  {
901  x = _x; y = _y; z = _z;
902  data[3] = 1.0f;
903  normal_x = n_x; normal_y = n_y; normal_z = n_z;
904  data_n[3] = 0.0f;
905  curvature = _curvature;
906  }
907 
908  friend std::ostream& operator << (std::ostream& os, const PointNormal& p);
909  };
910 
911 
912  struct EIGEN_ALIGN16 _PointXYZRGBNormal
913  {
914  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
915  PCL_ADD_NORMAL4D; // This adds the member normal[3] which can also be accessed using the point (which is float[4])
916  union
917  {
918  struct
919  {
921  float curvature;
922  };
923  float data_c[4];
924  };
927  };
928 
929  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZRGBNormal& p);
930  /** \brief A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate.
931  * Due to historical reasons (PCL was first developed as a ROS package), the
932  * RGB information is packed into an integer and casted to a float. This is
933  * something we wish to remove in the near future, but in the meantime, the
934  * following code snippet should help you pack and unpack RGB colors in your
935  * PointXYZRGB structure:
936  *
937  * \code
938  * // pack r/g/b into rgb
939  * std::uint8_t r = 255, g = 0, b = 0; // Example: Red color
940  * std::uint32_t rgb = ((std::uint32_t)r << 16 | (std::uint32_t)g << 8 | (std::uint32_t)b);
941  * p.rgb = *reinterpret_cast<float*>(&rgb);
942  * \endcode
943  *
944  * To unpack the data into separate values, use:
945  *
946  * \code
947  * PointXYZRGB p;
948  * // unpack rgb into r/g/b
949  * std::uint32_t rgb = *reinterpret_cast<int*>(&p.rgb);
950  * std::uint8_t r = (rgb >> 16) & 0x0000ff;
951  * std::uint8_t g = (rgb >> 8) & 0x0000ff;
952  * std::uint8_t b = (rgb) & 0x0000ff;
953  * \endcode
954  *
955  *
956  * Alternatively, from 1.1.0 onwards, you can use p.r, p.g, and p.b directly.
957  * \ingroup common
958  */
960  {
962  {
963  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
964  normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z; data_n[3] = 0.0f;
965  curvature = p.curvature;
966  rgba = p.rgba;
967  }
968 
969  inline PointXYZRGBNormal (float _curvature = 0.f):
970  PointXYZRGBNormal (0.f, 0.f, 0.f, 0, 0, 0, 0.f, 0.f, 0.f, _curvature) {}
971 
972  inline PointXYZRGBNormal (float _x, float _y, float _z):
973  PointXYZRGBNormal (_x, _y, _z, 0, 0, 0) {}
974 
975  inline PointXYZRGBNormal (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
976  PointXYZRGBNormal (0.f, 0.f, 0.f, _r, _g, _b) {}
977 
978  inline PointXYZRGBNormal (float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
979  PointXYZRGBNormal (_x, _y, _z, _r, _g, _b, 0.f, 0.f, 0.f) {}
980 
981  inline PointXYZRGBNormal (float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b,
982  float n_x, float n_y, float n_z, float _curvature = 0.f)
983  {
984  x = _x; y = _y; z = _z;
985  data[3] = 1.0f;
986  r = _r; g = _g; b = _b;
987  a = 255;
988  normal_x = n_x; normal_y = n_y; normal_z = n_z;
989  data_n[3] = 0.f;
990  curvature = _curvature;
991  }
992 
993  friend std::ostream& operator << (std::ostream& os, const PointXYZRGBNormal& p);
994  };
995 
996  struct EIGEN_ALIGN16 _PointXYZINormal
997  {
998  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
999  PCL_ADD_NORMAL4D; // This adds the member normal[3] which can also be accessed using the point (which is float[4])
1000  union
1001  {
1002  struct
1003  {
1004  float intensity;
1005  float curvature;
1006  };
1007  float data_c[4];
1008  };
1010  };
1011 
1012  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZINormal& p);
1013  /** \brief A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate.
1014  * \ingroup common
1015  */
1017  {
1019  {
1020  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
1021  normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z; data_n[3] = 0.0f;
1022  curvature = p.curvature;
1023  intensity = p.intensity;
1024  }
1025 
1026  inline PointXYZINormal (float _intensity = 0.f): PointXYZINormal (0.f, 0.f, 0.f, _intensity) {}
1027 
1028  inline PointXYZINormal (float _x, float _y, float _z, float _intensity = 0.f):
1029  PointXYZINormal (_x, _y, _z, _intensity, 0.f, 0.f, 0.f) {}
1030 
1031  inline PointXYZINormal (float _x, float _y, float _z, float _intensity,
1032  float n_x, float n_y, float n_z, float _curvature = 0.f)
1033  {
1034  x = _x; y = _y; z = _z;
1035  data[3] = 1.0f;
1036  intensity = _intensity;
1037  normal_x = n_x; normal_y = n_y; normal_z = n_z;
1038  data_n[3] = 0.f;
1039  curvature = _curvature;
1040  }
1041 
1042  friend std::ostream& operator << (std::ostream& os, const PointXYZINormal& p);
1043  };
1044 
1045 //----
1046  struct EIGEN_ALIGN16 _PointXYZLNormal
1047  {
1048  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
1049  PCL_ADD_NORMAL4D; // This adds the member normal[3] which can also be accessed using the point (which is float[4])
1050  union
1051  {
1052  struct
1053  {
1054  std::uint32_t label;
1055  float curvature;
1056  };
1057  float data_c[4];
1058  };
1060  };
1061 
1062  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZLNormal& p);
1063  /** \brief A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates and the surface curvature estimate.
1064  * \ingroup common
1065  */
1067  {
1069  {
1070  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
1071  normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z; data_n[3] = 0.0f;
1072  curvature = p.curvature;
1073  label = p.label;
1074  }
1075 
1076  inline PointXYZLNormal (std::uint32_t _label = 0): PointXYZLNormal (0.f, 0.f, 0.f, _label) {}
1077 
1078  inline PointXYZLNormal (float _x, float _y, float _z, std::uint32_t _label = 0.f):
1079  PointXYZLNormal (_x, _y, _z, _label, 0.f, 0.f, 0.f) {}
1080 
1081  inline PointXYZLNormal (float _x, float _y, float _z, std::uint32_t _label,
1082  float n_x, float n_y, float n_z, float _curvature = 0.f)
1083  {
1084  x = _x; y = _y; z = _z;
1085  data[3] = 1.0f;
1086  label = _label;
1087  normal_x = n_x; normal_y = n_y; normal_z = n_z;
1088  data_n[3] = 0.f;
1089  curvature = _curvature;
1090  }
1091 
1092  friend std::ostream& operator << (std::ostream& os, const PointXYZLNormal& p);
1093  };
1094 
1095 // ---
1096 
1097 
1098  struct EIGEN_ALIGN16 _PointWithRange
1099  {
1100  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
1101  union
1102  {
1103  struct
1104  {
1105  float range;
1106  };
1107  float data_c[4];
1108  };
1110  };
1111 
1112  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointWithRange& p);
1113  /** \brief A point structure representing Euclidean xyz coordinates, padded with an extra range float.
1114  * \ingroup common
1115  */
1117  {
1119  {
1120  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
1121  range = p.range;
1122  }
1123 
1124  inline PointWithRange (float _range = 0.f): PointWithRange (0.f, 0.f, 0.f, _range) {}
1125 
1126  inline PointWithRange (float _x, float _y, float _z, float _range = 0.f)
1127  {
1128  x = _x; y = _y; z = _z;
1129  data[3] = 1.0f;
1130  range = _range;
1131  }
1132 
1133  friend std::ostream& operator << (std::ostream& os, const PointWithRange& p);
1134  };
1135 
1136 
1137  struct EIGEN_ALIGN16 _PointWithViewpoint
1138  {
1139  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
1140  union
1141  {
1142  struct
1143  {
1144  float vp_x;
1145  float vp_y;
1146  float vp_z;
1147  };
1148  float data_c[4];
1149  };
1151  };
1152 
1153  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointWithViewpoint& p);
1154  /** \brief A point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen.
1155  * \ingroup common
1156  */
1157  struct EIGEN_ALIGN16 PointWithViewpoint : public _PointWithViewpoint
1158  {
1160  {
1161  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
1162  vp_x = p.vp_x; vp_y = p.vp_y; vp_z = p.vp_z;
1163  }
1164 
1165  inline PointWithViewpoint (): PointWithViewpoint (0.f, 0.f, 0.f) {}
1166 
1167  inline PointWithViewpoint (float _x, float _y, float _z): PointWithViewpoint (_x, _y, _z, 0.f, 0.f, 0.f) {}
1168 
1169  inline PointWithViewpoint (float _x, float _y, float _z, float _vp_x, float _vp_y, float _vp_z)
1170  {
1171  x = _x; y = _y; z = _z;
1172  data[3] = 1.0f;
1173  vp_x = _vp_x; vp_y = _vp_y; vp_z = _vp_z;
1174  }
1175 
1176  friend std::ostream& operator << (std::ostream& os, const PointWithViewpoint& p);
1177  };
1178 
1179  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const MomentInvariants& p);
1180  /** \brief A point structure representing the three moment invariants.
1181  * \ingroup common
1182  */
1184  {
1185  float j1 = 0.f, j2 = 0.f, j3 = 0.f;
1186 
1187  inline MomentInvariants () = default;
1188 
1189  inline MomentInvariants (float _j1, float _j2, float _j3): j1 (_j1), j2 (_j2), j3 (_j3) {}
1190 
1191  friend std::ostream& operator << (std::ostream& os, const MomentInvariants& p);
1192  };
1193 
1194  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PrincipalRadiiRSD& p);
1195  /** \brief A point structure representing the minimum and maximum surface radii (in meters) computed using RSD.
1196  * \ingroup common
1197  */
1199  {
1200  float r_min = 0.f, r_max = 0.f;
1201 
1202  inline PrincipalRadiiRSD () = default;
1203 
1204  inline PrincipalRadiiRSD (float _r_min, float _r_max): r_min (_r_min), r_max (_r_max) {}
1205 
1206  friend std::ostream& operator << (std::ostream& os, const PrincipalRadiiRSD& p);
1207  };
1208 
1209  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Boundary& p);
1210  /** \brief A point structure representing a description of whether a point is lying on a surface boundary or not.
1211  * \ingroup common
1212  */
1213  struct Boundary
1214  {
1215  std::uint8_t boundary_point = 0;
1216 
1217 #if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 1101
1218  operator unsigned char() const
1219  {
1220  return boundary_point;
1221  }
1222 #endif
1223 
1224  inline Boundary (std::uint8_t _boundary = 0): boundary_point (_boundary) {}
1225 
1226  friend std::ostream& operator << (std::ostream& os, const Boundary& p);
1227  };
1228 
1229  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PrincipalCurvatures& p);
1230  /** \brief A point structure representing the principal curvatures and their magnitudes.
1231  * \ingroup common
1232  */
1234  {
1235  union
1236  {
1238  struct
1239  {
1243  };
1244  };
1245  float pc1 = 0.f;
1246  float pc2 = 0.f;
1247 
1248  inline PrincipalCurvatures (): PrincipalCurvatures (0.f, 0.f) {}
1249 
1250  inline PrincipalCurvatures (float _pc1, float _pc2): PrincipalCurvatures (0.f, 0.f, 0.f, _pc1, _pc2) {}
1251 
1252  inline PrincipalCurvatures (float _x, float _y, float _z): PrincipalCurvatures (_x, _y, _z, 0.f, 0.f) {}
1253 
1254  inline PrincipalCurvatures (float _x, float _y, float _z, float _pc1, float _pc2):
1255  principal_curvature_x (_x), principal_curvature_y (_y), principal_curvature_z (_z), pc1 (_pc1), pc2 (_pc2) {}
1256 
1257  friend std::ostream& operator << (std::ostream& os, const PrincipalCurvatures& p);
1258  };
1259 
1260  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PFHSignature125& p);
1261  /** \brief A point structure representing the Point Feature Histogram (PFH).
1262  * \ingroup common
1263  */
1265  {
1266  float histogram[125] = {0.f};
1267  static int descriptorSize () { return 125; }
1268 
1269  inline PFHSignature125 () = default;
1270 
1271  friend std::ostream& operator << (std::ostream& os, const PFHSignature125& p);
1272  };
1273 
1274  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PFHRGBSignature250& p);
1275  /** \brief A point structure representing the Point Feature Histogram with colors (PFHRGB).
1276  * \ingroup common
1277  */
1279  {
1280  float histogram[250] = {0.f};
1281  static int descriptorSize () { return 250; }
1282 
1283  inline PFHRGBSignature250 () = default;
1284 
1285  friend std::ostream& operator << (std::ostream& os, const PFHRGBSignature250& p);
1286  };
1287 
1288  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PPFSignature& p);
1289  /** \brief A point structure for storing the Point Pair Feature (PPF) values
1290  * \ingroup common
1291  */
1293  {
1294  float f1 = 0.f, f2 = 0.f, f3 = 0.f, f4 = 0.f;
1295  float alpha_m = 0.f;
1296 
1297  inline PPFSignature (float _alpha = 0.f): PPFSignature (0.f, 0.f, 0.f, 0.f, _alpha) {}
1298 
1299  inline PPFSignature (float _f1, float _f2, float _f3, float _f4, float _alpha = 0.f):
1300  f1 (_f1), f2 (_f2), f3 (_f3), f4 (_f4), alpha_m (_alpha) {}
1301 
1302  friend std::ostream& operator << (std::ostream& os, const PPFSignature& p);
1303  };
1304 
1305  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const CPPFSignature& p);
1306  /** \brief A point structure for storing the Point Pair Feature (CPPF) values
1307  * \ingroup common
1308  */
1310  {
1311  float f1, f2, f3, f4, f5, f6, f7, f8, f9, f10;
1312  float alpha_m;
1313 
1314  inline CPPFSignature (float _alpha = 0.f):
1315  CPPFSignature (0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, _alpha) {}
1316 
1317  inline CPPFSignature (float _f1, float _f2, float _f3, float _f4, float _f5, float _f6,
1318  float _f7, float _f8, float _f9, float _f10, float _alpha = 0.f):
1319  f1 (_f1), f2 (_f2), f3 (_f3), f4 (_f4), f5 (_f5), f6 (_f6),
1320  f7 (_f7), f8 (_f8), f9 (_f9), f10 (_f10), alpha_m (_alpha) {}
1321 
1322  friend std::ostream& operator << (std::ostream& os, const CPPFSignature& p);
1323  };
1324 
1325  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PPFRGBSignature& p);
1326  /** \brief A point structure for storing the Point Pair Color Feature (PPFRGB) values
1327  * \ingroup common
1328  */
1330  {
1331  float f1 = 0.f, f2 = 0.f, f3 = 0.f, f4 = 0.f;
1332  float r_ratio = 0.f, g_ratio = 0.f, b_ratio = 0.f;
1333  float alpha_m = 0.f;
1334 
1335  inline PPFRGBSignature (float _alpha = 0.f): PPFRGBSignature (0.f, 0.f, 0.f, 0.f, _alpha) {}
1336 
1337  inline PPFRGBSignature (float _f1, float _f2, float _f3, float _f4, float _alpha = 0.f):
1338  PPFRGBSignature (_f1, _f2, _f3, _f4, _alpha, 0.f, 0.f, 0.f) {}
1339 
1340  inline PPFRGBSignature (float _f1, float _f2, float _f3, float _f4, float _alpha, float _r, float _g, float _b):
1341  f1 (_f1), f2 (_f2), f3 (_f3), f4 (_f4), r_ratio (_r), g_ratio (_g), b_ratio (_b), alpha_m (_alpha) {}
1342 
1343  friend std::ostream& operator << (std::ostream& os, const PPFRGBSignature& p);
1344  };
1345 
1346  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const NormalBasedSignature12& p);
1347  /** \brief A point structure representing the Normal Based Signature for
1348  * a feature matrix of 4-by-3
1349  * \ingroup common
1350  */
1352  {
1353  float values[12] = {0.f};
1354 
1355  inline NormalBasedSignature12 () = default;
1356 
1357  friend std::ostream& operator << (std::ostream& os, const NormalBasedSignature12& p);
1358  };
1359 
1360  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const ShapeContext1980& p);
1361  /** \brief A point structure representing a Shape Context.
1362  * \ingroup common
1363  */
1365  {
1366  float descriptor[1980] = {0.f};
1367  float rf[9] = {0.f};
1368  static int descriptorSize () { return 1980; }
1369 
1370  inline ShapeContext1980 () = default;
1371 
1372  friend std::ostream& operator << (std::ostream& os, const ShapeContext1980& p);
1373  };
1374 
1375  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const UniqueShapeContext1960& p);
1376  /** \brief A point structure representing a Unique Shape Context.
1377  * \ingroup common
1378  */
1380  {
1381  float descriptor[1960] = {0.f};
1382  float rf[9] = {0.f};
1383  static int descriptorSize () { return 1960; }
1384 
1385  inline UniqueShapeContext1960 () = default;
1386 
1387  friend std::ostream& operator << (std::ostream& os, const UniqueShapeContext1960& p);
1388  };
1389 
1390  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const SHOT352& p);
1391  /** \brief A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape only.
1392  * \ingroup common
1393  */
1394  struct SHOT352
1395  {
1396  float descriptor[352] = {0.f};
1397  float rf[9] = {0.f};
1398  static int descriptorSize () { return 352; }
1399 
1400  inline SHOT352 () = default;
1401 
1402  friend std::ostream& operator << (std::ostream& os, const SHOT352& p);
1403  };
1404 
1405 
1406  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const SHOT1344& p);
1407  /** \brief A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+color.
1408  * \ingroup common
1409  */
1410  struct SHOT1344
1411  {
1412  float descriptor[1344] = {0.f};
1413  float rf[9] = {0.f};
1414  static int descriptorSize () { return 1344; }
1415 
1416  inline SHOT1344 () = default;
1417 
1418  friend std::ostream& operator << (std::ostream& os, const SHOT1344& p);
1419  };
1420 
1421 
1422  /** \brief A structure representing the Local Reference Frame of a point.
1423  * \ingroup common
1424  */
1425  struct EIGEN_ALIGN16 _ReferenceFrame
1426  {
1427  union
1428  {
1429  float rf[9];
1430  struct
1431  {
1432  float x_axis[3];
1433  float y_axis[3];
1434  float z_axis[3];
1435  };
1436  };
1437 
1438  inline Eigen::Map<Eigen::Vector3f> getXAxisVector3fMap () { return (Eigen::Vector3f::Map (x_axis)); }
1439  inline const Eigen::Map<const Eigen::Vector3f> getXAxisVector3fMap () const { return (Eigen::Vector3f::Map (x_axis)); }
1440  inline Eigen::Map<Eigen::Vector3f> getYAxisVector3fMap () { return (Eigen::Vector3f::Map (y_axis)); }
1441  inline const Eigen::Map<const Eigen::Vector3f> getYAxisVector3fMap () const { return (Eigen::Vector3f::Map (y_axis)); }
1442  inline Eigen::Map<Eigen::Vector3f> getZAxisVector3fMap () { return (Eigen::Vector3f::Map (z_axis)); }
1443  inline const Eigen::Map<const Eigen::Vector3f> getZAxisVector3fMap () const { return (Eigen::Vector3f::Map (z_axis)); }
1444  inline Eigen::Map<Eigen::Matrix3f> getMatrix3fMap () { return (Eigen::Matrix3f::Map (rf)); }
1445  inline const Eigen::Map<const Eigen::Matrix3f> getMatrix3fMap () const { return (Eigen::Matrix3f::Map (rf)); }
1446 
1448  };
1449 
1450  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const ReferenceFrame& p);
1451  struct EIGEN_ALIGN16 ReferenceFrame : public _ReferenceFrame
1452  {
1454  {
1455  std::copy_n(p.rf, 9, rf);
1456  }
1457 
1458  inline ReferenceFrame ()
1459  {
1460  std::fill_n(x_axis, 3, 0.f);
1461  std::fill_n(y_axis, 3, 0.f);
1462  std::fill_n(z_axis, 3, 0.f);
1463  }
1464 
1465  // @TODO: add other ctors
1466 
1467  friend std::ostream& operator << (std::ostream& os, const ReferenceFrame& p);
1469  };
1470 
1471 
1472  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const FPFHSignature33& p);
1473  /** \brief A point structure representing the Fast Point Feature Histogram (FPFH).
1474  * \ingroup common
1475  */
1477  {
1478  float histogram[33] = {0.f};
1479  static int descriptorSize () { return 33; }
1480 
1481  inline FPFHSignature33 () = default;
1482 
1483  friend std::ostream& operator << (std::ostream& os, const FPFHSignature33& p);
1484  };
1485 
1486  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const VFHSignature308& p);
1487  /** \brief A point structure representing the Viewpoint Feature Histogram (VFH).
1488  * \ingroup common
1489  */
1491  {
1492  float histogram[308] = {0.f};
1493  static int descriptorSize () { return 308; }
1494 
1495  inline VFHSignature308 () = default;
1496 
1497  friend std::ostream& operator << (std::ostream& os, const VFHSignature308& p);
1498  };
1499 
1500  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GRSDSignature21& p);
1501  /** \brief A point structure representing the Global Radius-based Surface Descriptor (GRSD).
1502  * \ingroup common
1503  */
1505  {
1506  float histogram[21] = {0.f};
1507  static int descriptorSize () { return 21; }
1508 
1509  inline GRSDSignature21 () = default;
1510 
1511  friend std::ostream& operator << (std::ostream& os, const GRSDSignature21& p);
1512  };
1513 
1514  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const BRISKSignature512& p);
1515  /** \brief A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK).
1516  * \ingroup common
1517  */
1519  {
1520  float scale = 0.f;
1521  float orientation = 0.f;
1522  unsigned char descriptor[64] = {0};
1523  static int descriptorSize () { return 64; }
1524 
1525  inline BRISKSignature512 () = default;
1526 
1527  inline BRISKSignature512 (float _scale, float _orientation): scale (_scale), orientation (_orientation) {}
1528 
1529  friend std::ostream& operator << (std::ostream& os, const BRISKSignature512& p);
1530  };
1531 
1532  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const ESFSignature640& p);
1533  /** \brief A point structure representing the Ensemble of Shape Functions (ESF).
1534  * \ingroup common
1535  */
1537  {
1538  float histogram[640] = {0.f};
1539  static int descriptorSize () { return 640; }
1540 
1541  inline ESFSignature640 () = default;
1542 
1543  friend std::ostream& operator << (std::ostream& os, const ESFSignature640& p);
1544  };
1545 
1546  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GASDSignature512& p);
1547  /** \brief A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor.
1548  * \ingroup common
1549  */
1551  {
1552  float histogram[512] = {0.f};
1553  static int descriptorSize() { return 512; }
1554 
1555  inline GASDSignature512 () = default;
1556 
1557  friend std::ostream& operator << (std::ostream& os, const GASDSignature512& p);
1558  };
1559 
1560  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GASDSignature984& p);
1561  /** \brief A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor.
1562  * \ingroup common
1563  */
1565  {
1566  float histogram[984] = {0.f};
1567  static int descriptorSize() { return 984; }
1568 
1569  inline GASDSignature984 () = default;
1570 
1571  friend std::ostream& operator << (std::ostream& os, const GASDSignature984& p);
1572  };
1573 
1574  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GASDSignature7992& p);
1575  /** \brief A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor.
1576  * \ingroup common
1577  */
1579  {
1580  float histogram[7992] = {0.f};
1581  static int descriptorSize() { return 7992; }
1582 
1583  inline GASDSignature7992 () = default;
1584 
1585  friend std::ostream& operator << (std::ostream& os, const GASDSignature7992& p);
1586  };
1587 
1588  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GFPFHSignature16& p);
1589  /** \brief A point structure representing the GFPFH descriptor with 16 bins.
1590  * \ingroup common
1591  */
1593  {
1594  float histogram[16] = {0.f};
1595  static int descriptorSize () { return 16; }
1596 
1597  inline GFPFHSignature16 () = default;
1598 
1599  friend std::ostream& operator << (std::ostream& os, const GFPFHSignature16& p);
1600  };
1601 
1602  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Narf36& p);
1603  /** \brief A point structure representing the Narf descriptor.
1604  * \ingroup common
1605  */
1606  struct Narf36
1607  {
1608  float x = 0.f, y = 0.f, z = 0.f, roll = 0.f, pitch = 0.f, yaw = 0.f;
1609  float descriptor[36] = {0.f};
1610  static int descriptorSize () { return 36; }
1611 
1612  inline Narf36 () = default;
1613 
1614  inline Narf36 (float _x, float _y, float _z): Narf36 (_x, _y, _z, 0.f, 0.f, 0.f) {}
1615 
1616  inline Narf36 (float _x, float _y, float _z, float _roll, float _pitch, float _yaw):
1617  x (_x), y (_y), z (_z), roll (_roll), pitch (_pitch), yaw (_yaw) {}
1618 
1619  friend std::ostream& operator << (std::ostream& os, const Narf36& p);
1620  };
1621 
1622  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const BorderDescription& p);
1623  /** \brief A structure to store if a point in a range image lies on a border between an obstacle and the background.
1624  * \ingroup common
1625  */
1627  {
1628  int x = 0, y = 0;
1630  //std::vector<const BorderDescription*> neighbors;
1631 
1632  inline BorderDescription () = default;
1633 
1634  // TODO: provide other ctors
1635 
1636  friend std::ostream& operator << (std::ostream& os, const BorderDescription& p);
1637  };
1638 
1639 
1640  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const IntensityGradient& p);
1641  /** \brief A point structure representing the intensity gradient of an XYZI point cloud.
1642  * \ingroup common
1643  */
1645  {
1646  union
1647  {
1648  float gradient[3];
1649  struct
1650  {
1651  float gradient_x;
1652  float gradient_y;
1653  float gradient_z;
1654  };
1655  };
1656 
1657  inline IntensityGradient (): IntensityGradient (0.f, 0.f, 0.f) {}
1658 
1659  inline IntensityGradient (float _x, float _y, float _z): gradient_x (_x), gradient_y (_y), gradient_z (_z) {}
1660 
1661  friend std::ostream& operator << (std::ostream& os, const IntensityGradient& p);
1662  };
1663 
1664  // TODO: Maybe make other histogram based structs an alias for this
1665  /** \brief A point structure representing an N-D histogram.
1666  * \ingroup common
1667  */
1668  template <int N>
1669  struct Histogram
1670  {
1671  float histogram[N];
1672  static int descriptorSize () { return N; }
1673  };
1674 
1675  struct EIGEN_ALIGN16 _PointWithScale
1676  {
1677  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
1678 
1679  union
1680  {
1681  /** \brief Diameter of the meaningful keypoint neighborhood. */
1682  float scale;
1683  float size;
1684  };
1685 
1686  /** \brief Computed orientation of the keypoint (-1 if not applicable). */
1687  float angle;
1688  /** \brief The response by which the most strong keypoints have been selected. */
1689  float response;
1690  /** \brief octave (pyramid layer) from which the keypoint has been extracted. */
1691  int octave;
1692 
1694  };
1695 
1696  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointWithScale& p);
1697  /** \brief A point structure representing a 3-D position and scale.
1698  * \ingroup common
1699  */
1701  {
1703  {
1704  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
1705  scale = p.scale;
1706  angle = p.angle;
1707  response = p.response;
1708  octave = p.octave;
1709  }
1710 
1711  inline PointWithScale (): PointWithScale (0.f, 0.f, 0.f) {}
1712 
1713  inline PointWithScale (float _x, float _y, float _z, float _scale = 1.f,
1714  float _angle = -1.f, float _response = 0.f, int _octave = 0)
1715  {
1716  x = _x; y = _y; z = _z;
1717  data[3] = 1.0f;
1718  scale = _scale;
1719  angle = _angle;
1720  response = _response;
1721  octave = _octave;
1722  }
1723 
1724  friend std::ostream& operator << (std::ostream& os, const PointWithScale& p);
1725  };
1726 
1727 
1728  struct EIGEN_ALIGN16 _PointSurfel
1729  {
1730  PCL_ADD_POINT4D; // This adds the members x,y,z which can also be accessed using the point (which is float[4])
1731  PCL_ADD_NORMAL4D; // This adds the member normal[3] which can also be accessed using the point (which is float[4])
1732  union
1733  {
1734  struct
1735  {
1737  float radius;
1738  float confidence;
1739  float curvature;
1740  };
1741  float data_c[4];
1742  };
1745  };
1746 
1747  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointSurfel& p);
1748  /** \brief A surfel, that is, a point structure representing Euclidean xyz coordinates, together with normal coordinates, a RGBA color, a radius, a confidence value and the surface curvature estimate.
1749  * \ingroup common
1750  */
1751  struct PointSurfel : public _PointSurfel
1752  {
1753  inline PointSurfel (const _PointSurfel &p)
1754  {
1755  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
1756  rgba = p.rgba;
1757  radius = p.radius;
1758  confidence = p.confidence;
1759  curvature = p.curvature;
1760  }
1761 
1762  inline PointSurfel ()
1763  {
1764  x = y = z = 0.0f;
1765  data[3] = 1.0f;
1766  normal_x = normal_y = normal_z = data_n[3] = 0.0f;
1767  r = g = b = 0;
1768  a = 255;
1769  radius = confidence = curvature = 0.0f;
1770  }
1771 
1772  // TODO: add other ctor to PointSurfel
1773 
1774  friend std::ostream& operator << (std::ostream& os, const PointSurfel& p);
1775  };
1776 
1777  struct EIGEN_ALIGN16 _PointDEM
1778  {
1780  float intensity;
1784  };
1785 
1786  PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointDEM& p);
1787  /** \brief A point structure representing Digital Elevation Map.
1788  * \ingroup common
1789  */
1790  struct PointDEM : public _PointDEM
1791  {
1792  inline PointDEM (const _PointDEM &p)
1793  {
1794  x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
1795  intensity = p.intensity;
1798  }
1799 
1800  inline PointDEM (): PointDEM (0.f, 0.f, 0.f) {}
1801 
1802  inline PointDEM (float _x, float _y, float _z): PointDEM (_x, _y, _z, 0.f, 0.f, 0.f) {}
1803 
1804  inline PointDEM (float _x, float _y, float _z, float _intensity,
1805  float _intensity_variance, float _height_variance)
1806  {
1807  x = _x; y = _y; z = _z;
1808  data[3] = 1.0f;
1809  intensity = _intensity;
1810  intensity_variance = _intensity_variance;
1811  height_variance = _height_variance;
1812  }
1813 
1814  friend std::ostream& operator << (std::ostream& os, const PointDEM& p);
1815  };
1816 
1817  template <int N> std::ostream&
1818  operator << (std::ostream& os, const Histogram<N>& p)
1819  {
1820  // make constexpr
1821  if (N > 0)
1822  {
1823  os << "(" << p.histogram[0];
1824  std::for_each(p.histogram + 1, std::end(p.histogram),
1825  [&os](const auto& hist) { os << ", " << hist; });
1826  os << ")";
1827  }
1828  return (os);
1829  }
1830 } // namespace pcl
1831 
1832 // Register point structs and wrappers
1834  (std::uint32_t, rgba, rgba)
1835 )
1836 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::RGB, pcl::_RGB)
1837 
1839  (float, intensity, intensity)
1840 )
1841 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity, pcl::_Intensity)
1842 
1844  (std::uint8_t, intensity, intensity)
1845 )
1846 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity8u, pcl::_Intensity8u)
1847 
1849  (std::uint32_t, intensity, intensity)
1850 )
1851 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity32u, pcl::_Intensity32u)
1852 
1854  (float, x, x)
1855  (float, y, y)
1856  (float, z, z)
1857 )
1858 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZ, pcl::_PointXYZ)
1859 
1861  (float, x, x)
1862  (float, y, y)
1863  (float, z, z)
1864  (std::uint32_t, rgba, rgba)
1865 )
1866 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBA, pcl::_PointXYZRGBA)
1867 
1869  (float, x, x)
1870  (float, y, y)
1871  (float, z, z)
1872  (float, rgb, rgb)
1873 )
1874 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGB, pcl::_PointXYZRGB)
1875 
1877  (float, x, x)
1878  (float, y, y)
1879  (float, z, z)
1880  (std::uint32_t, rgba, rgba)
1881  (std::uint32_t, label, label)
1882 )
1883 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBL, pcl::_PointXYZRGBL)
1884 
1886  (float, x, x)
1887  (float, y, y)
1888  (float, z, z)
1889  (float, h, h)
1890  (float, s, s)
1891  (float, v, v)
1892 )
1893 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZHSV, pcl::_PointXYZHSV)
1894 
1896  (float, x, x)
1897  (float, y, y)
1898 )
1899 
1901  (float, u, u)
1902  (float, v, v)
1903 )
1904 
1906  (float, x, x)
1907  (float, y, y)
1908  (float, z, z)
1909  (float, strength, strength)
1910 )
1911 
1913  (float, x, x)
1914  (float, y, y)
1915  (float, z, z)
1916  (float, intensity, intensity)
1917 )
1918 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZI, pcl::_PointXYZI)
1919 
1921  (float, x, x)
1922  (float, y, y)
1923  (float, z, z)
1924  (std::uint32_t, label, label)
1925 )
1926 
1928  (std::uint32_t, label, label)
1929 )
1930 
1932  (float, normal_x, normal_x)
1933  (float, normal_y, normal_y)
1934  (float, normal_z, normal_z)
1935  (float, curvature, curvature)
1936 )
1937 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Normal, pcl::_Normal)
1938 
1940  (float, normal_x, normal_x)
1941  (float, normal_y, normal_y)
1942  (float, normal_z, normal_z)
1943 )
1944 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Axis, pcl::_Axis)
1945 
1947  (float, x, x)
1948  (float, y, y)
1949  (float, z, z)
1950  (float, normal_x, normal_x)
1951  (float, normal_y, normal_y)
1952  (float, normal_z, normal_z)
1953  (float, curvature, curvature)
1954 )
1956  (float, x, x)
1957  (float, y, y)
1958  (float, z, z)
1959  (float, rgb, rgb)
1960  (float, normal_x, normal_x)
1961  (float, normal_y, normal_y)
1962  (float, normal_z, normal_z)
1963  (float, curvature, curvature)
1964 )
1965 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBNormal, pcl::_PointXYZRGBNormal)
1967  (float, x, x)
1968  (float, y, y)
1969  (float, z, z)
1970  (float, intensity, intensity)
1971  (float, normal_x, normal_x)
1972  (float, normal_y, normal_y)
1973  (float, normal_z, normal_z)
1974  (float, curvature, curvature)
1975 )
1977  (float, x, x)
1978  (float, y, y)
1979  (float, z, z)
1980  (std::uint32_t, label, label)
1981  (float, normal_x, normal_x)
1982  (float, normal_y, normal_y)
1983  (float, normal_z, normal_z)
1984  (float, curvature, curvature)
1985 )
1987  (float, x, x)
1988  (float, y, y)
1989  (float, z, z)
1990  (float, range, range)
1991 )
1992 
1994  (float, x, x)
1995  (float, y, y)
1996  (float, z, z)
1997  (float, vp_x, vp_x)
1998  (float, vp_y, vp_y)
1999  (float, vp_z, vp_z)
2000 )
2001 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointWithViewpoint, pcl::_PointWithViewpoint)
2002 
2004  (float, j1, j1)
2005  (float, j2, j2)
2006  (float, j3, j3)
2007 )
2008 
2010  (float, r_min, r_min)
2011  (float, r_max, r_max)
2012 )
2013 
2015  (std::uint8_t, boundary_point, boundary_point)
2016 )
2017 
2019  (float, principal_curvature_x, principal_curvature_x)
2020  (float, principal_curvature_y, principal_curvature_y)
2021  (float, principal_curvature_z, principal_curvature_z)
2022  (float, pc1, pc1)
2023  (float, pc2, pc2)
2024 )
2025 
2027  (float[125], histogram, pfh)
2028 )
2029 
2031  (float[250], histogram, pfhrgb)
2032 )
2033 
2035  (float, f1, f1)
2036  (float, f2, f2)
2037  (float, f3, f3)
2038  (float, f4, f4)
2039  (float, alpha_m, alpha_m)
2040 )
2041 
2043  (float, f1, f1)
2044  (float, f2, f2)
2045  (float, f3, f3)
2046  (float, f4, f4)
2047  (float, f5, f5)
2048  (float, f6, f6)
2049  (float, f7, f7)
2050  (float, f8, f8)
2051  (float, f9, f9)
2052  (float, f10, f10)
2053  (float, alpha_m, alpha_m)
2054 )
2055 
2057  (float, f1, f1)
2058  (float, f2, f2)
2059  (float, f3, f3)
2060  (float, f4, f4)
2061  (float, r_ratio, r_ratio)
2062  (float, g_ratio, g_ratio)
2063  (float, b_ratio, b_ratio)
2064  (float, alpha_m, alpha_m)
2065 )
2066 
2068  (float[12], values, values)
2069 )
2070 
2072  (float[1980], descriptor, shape_context)
2073  (float[9], rf, rf)
2074 )
2075 
2077  (float[1960], descriptor, shape_context)
2078  (float[9], rf, rf)
2079 )
2080 
2082  (float[352], descriptor, shot)
2083  (float[9], rf, rf)
2084 )
2085 
2087  (float[1344], descriptor, shot)
2088  (float[9], rf, rf)
2089 )
2090 
2092  (float[33], histogram, fpfh)
2093 )
2094 
2096  (float, scale, brisk_scale)
2097  (float, orientation, brisk_orientation)
2098  (unsigned char[64], descriptor, brisk_descriptor512)
2099 )
2100 
2102  (float[308], histogram, vfh)
2103 )
2104 
2106  (float[21], histogram, grsd)
2107 )
2108 
2110  (float[640], histogram, esf)
2111 )
2112 
2114  (float[512], histogram, gasd)
2115 )
2116 
2118  (float[984], histogram, gasd)
2119 )
2120 
2122  (float[7992], histogram, gasd)
2123 )
2124 
2126  (float[36], descriptor, descriptor)
2127 )
2128 
2130  (float[16], histogram, gfpfh)
2131 )
2132 
2134  (float, gradient_x, gradient_x)
2135  (float, gradient_y, gradient_y)
2136  (float, gradient_z, gradient_z)
2137 )
2138 
2140  (float, x, x)
2141  (float, y, y)
2142  (float, z, z)
2143  (float, scale, scale)
2144 )
2145 
2147  (float, x, x)
2148  (float, y, y)
2149  (float, z, z)
2150  (float, normal_x, normal_x)
2151  (float, normal_y, normal_y)
2152  (float, normal_z, normal_z)
2153  (std::uint32_t, rgba, rgba)
2154  (float, radius, radius)
2155  (float, confidence, confidence)
2156  (float, curvature, curvature)
2157 )
2158 
2160  (float[3], x_axis, x_axis)
2161  (float[3], y_axis, y_axis)
2162  (float[3], z_axis, z_axis)
2163 )
2164 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::ReferenceFrame, pcl::_ReferenceFrame)
2165 
2167  (float, x, x)
2168  (float, y, y)
2169  (float, z, z)
2170  (float, intensity, intensity)
2171  (float, intensity_variance, intensity_variance)
2172  (float, height_variance, height_variance)
2173 )
2174 POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointDEM, pcl::_PointDEM)
2175 
2176 namespace pcl
2177 {
2178 
2179 // Allow float 'rgb' data to match to the newer uint32 'rgba' tag. This is so
2180 // you can load old 'rgb' PCD files into e.g. a PointCloud<PointXYZRGBA>.
2181 template<typename PointT>
2182 struct FieldMatches<PointT, ::pcl::fields::rgba>
2183 {
2184  bool operator() (const pcl::PCLPointField& field)
2185  {
2186  if (field.name == "rgb")
2187  {
2188  // For fixing the alpha value bug #1141, the rgb field can also match
2189  // uint32.
2190  return ((field.datatype == pcl::PCLPointField::FLOAT32 ||
2192  field.count == 1);
2193  }
2194  else
2195  {
2196  return (field.name == traits::name<PointT, fields::rgba>::value &&
2197  field.datatype == traits::datatype<PointT, fields::rgba>::value &&
2198  field.count == traits::datatype<PointT, fields::rgba>::size);
2199  }
2200  }
2201 };
2202 template<typename PointT>
2203 struct FieldMatches<PointT, fields::rgb>
2204 {
2205  bool operator() (const pcl::PCLPointField& field)
2206  {
2207  if (field.name == "rgba")
2208  {
2209  return (field.datatype == pcl::PCLPointField::UINT32 &&
2210  field.count == 1);
2211  }
2212  else
2213  {
2214  // For fixing the alpha value bug #1141, rgb can also match uint32
2215  return (field.name == traits::name<PointT, fields::rgb>::value &&
2216  (field.datatype == traits::datatype<PointT, fields::rgb>::value ||
2218  field.count == traits::datatype<PointT, fields::rgb>::size);
2219  }
2220  }
2221 };
2222 
2223 
2224 // We're doing a lot of black magic with Boost here, so disable warnings in Maintainer mode, as we will never
2225 // be able to fix them anyway
2226 #if defined _MSC_VER
2227  #pragma warning(disable: 4201)
2228 #endif
2229 
2230 namespace traits
2231 {
2232 
2233  /** \brief Metafunction to check if a given point type has a given field.
2234  *
2235  * Example usage at run-time:
2236  *
2237  * \code
2238  * bool curvature_available = pcl::traits::has_field<PointT, pcl::fields::curvature>::value;
2239  * \endcode
2240  *
2241  * Example usage at compile-time:
2242  *
2243  * \code
2244  * BOOST_MPL_ASSERT_MSG ((pcl::traits::has_field<PointT, pcl::fields::label>::value),
2245  * POINT_TYPE_SHOULD_HAVE_LABEL_FIELD,
2246  * (PointT));
2247  * \endcode
2248  */
2249  template <typename PointT, typename Field>
2250  struct has_field : boost::mpl::contains<typename pcl::traits::fieldList<PointT>::type, Field>::type
2251  { };
2252 
2253  /** Metafunction to check if a given point type has all given fields. */
2254  template <typename PointT, typename Field>
2255  struct has_all_fields : boost::mpl::fold<Field,
2256  boost::mpl::bool_<true>,
2257  boost::mpl::and_<boost::mpl::_1,
2258  has_field<PointT, boost::mpl::_2> > >::type
2259  { };
2260 
2261  /** Metafunction to check if a given point type has any of the given fields. */
2262  template <typename PointT, typename Field>
2263  struct has_any_field : boost::mpl::fold<Field,
2264  boost::mpl::bool_<false>,
2265  boost::mpl::or_<boost::mpl::_1,
2266  has_field<PointT, boost::mpl::_2> > >::type
2267  { };
2268 
2269  /** \brief Traits defined for ease of use with fields already registered before
2270  *
2271  * has_<fields to be detected>: struct with `value` datamember defined at compiletime
2272  * has_<fields to be detected>_v: constexpr boolean
2273  * Has<Fields to be detected>: concept modelling name alias for `enable_if`
2274  */
2275 
2276  /** Metafunction to check if a given point type has x and y fields. */
2277  template <typename PointT>
2278  struct has_xy : has_all_fields<PointT, boost::mpl::vector<pcl::fields::x,
2279  pcl::fields::y> >
2280  { };
2281 
2282  template <typename PointT>
2283  constexpr auto has_xy_v = has_xy<PointT>::value;
2284 
2285  template <typename PointT>
2286  using HasXY = std::enable_if_t<has_xy_v<PointT>, bool>;
2287 
2288  template <typename PointT>
2289  using HasNoXY = std::enable_if_t<!has_xy_v<PointT>, bool>;
2290 
2291  /** Metafunction to check if a given point type has x, y, and z fields. */
2292  template <typename PointT>
2293  struct has_xyz : has_all_fields<PointT, boost::mpl::vector<pcl::fields::x,
2294  pcl::fields::y,
2295  pcl::fields::z> >
2296  { };
2297 
2298  template <typename PointT>
2299  constexpr auto has_xyz_v = has_xyz<PointT>::value;
2300 
2301  template <typename PointT>
2302  using HasXYZ = std::enable_if_t<has_xyz_v<PointT>, bool>;
2303 
2304  template <typename PointT>
2305  using HasNoXYZ = std::enable_if_t<!has_xyz_v<PointT>, bool>;
2306 
2307  /** Metafunction to check if a given point type has normal_x, normal_y, and
2308  * normal_z fields. */
2309  template <typename PointT>
2310  struct has_normal : has_all_fields<PointT, boost::mpl::vector<pcl::fields::normal_x,
2311  pcl::fields::normal_y,
2312  pcl::fields::normal_z> >
2313  { };
2314 
2315  template <typename PointT>
2316  constexpr auto has_normal_v = has_normal<PointT>::value;
2317 
2318  template <typename PointT>
2319  using HasNormal = std::enable_if_t<has_normal_v<PointT>, bool>;
2320 
2321  template <typename PointT>
2322  using HasNoNormal = std::enable_if_t<!has_normal_v<PointT>, bool>;
2323 
2324  /** Metafunction to check if a given point type has curvature field. */
2325  template <typename PointT>
2326  struct has_curvature : has_field<PointT, pcl::fields::curvature>
2327  { };
2328 
2329  template <typename PointT>
2330  constexpr auto has_curvature_v = has_curvature<PointT>::value;
2331 
2332  template <typename PointT>
2333  using HasCurvature = std::enable_if_t<has_curvature_v<PointT>, bool>;
2334 
2335  template <typename PointT>
2336  using HasNoCurvature = std::enable_if_t<!has_curvature_v<PointT>, bool>;
2337 
2338  /** Metafunction to check if a given point type has intensity field. */
2339  template <typename PointT>
2340  struct has_intensity : has_field<PointT, pcl::fields::intensity>
2341  { };
2342 
2343  template <typename PointT>
2344  constexpr auto has_intensity_v = has_intensity<PointT>::value;
2345 
2346  template <typename PointT>
2347  using HasIntensity = std::enable_if_t<has_intensity_v<PointT>, bool>;
2348 
2349  template <typename PointT>
2350  using HasNoIntensity = std::enable_if_t<!has_intensity_v<PointT>, bool>;
2351 
2352  /** Metafunction to check if a given point type has either rgb or rgba field. */
2353  template <typename PointT>
2354  struct has_color : has_any_field<PointT, boost::mpl::vector<pcl::fields::rgb,
2355  pcl::fields::rgba> >
2356  { };
2357 
2358  template <typename PointT>
2359  constexpr auto has_color_v = has_color<PointT>::value;
2360 
2361  template <typename PointT>
2362  using HasColor = std::enable_if_t<has_color_v<PointT>, bool>;
2363 
2364  template <typename PointT>
2365  using HasNoColor = std::enable_if_t<!has_color_v<PointT>, bool>;
2366 
2367  /** Metafunction to check if a given point type has label field. */
2368  template <typename PointT>
2369  struct has_label : has_field<PointT, pcl::fields::label>
2370  { };
2371 
2372  template <typename PointT>
2373  constexpr auto has_label_v = has_label<PointT>::value;
2374 
2375  template <typename PointT>
2376  using HasLabel = std::enable_if_t<has_label_v<PointT>, bool>;
2377 
2378  template <typename PointT>
2379  using HasNoLabel = std::enable_if_t<!has_label_v<PointT>, bool>;
2380 }
2381 
2382 #if defined _MSC_VER
2383  #pragma warning(default: 4201)
2384 #endif
2385 
2386 } // namespace pcl
2387 
pcl::PointUV
A 2D point structure representing pixel image coordinates.
Definition: point_types.hpp:761
pcl::Intensity::Intensity
Intensity(float _intensity=0.f)
Definition: point_types.hpp:380
pcl::PointWithViewpoint::PointWithViewpoint
PointWithViewpoint(float _x, float _y, float _z)
Definition: point_types.hpp:1167
pcl::GRSDSignature21::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1507
pcl::_PointDEM::intensity_variance
float intensity_variance
Definition: point_types.hpp:1781
pcl::Label::Label
Label(std::uint32_t _label=0)
Definition: point_types.hpp:519
pcl::_PointWithScale::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1677
pcl::CPPFSignature::f8
float f8
Definition: point_types.hpp:1311
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(float _x, float _y, float _z)
Definition: point_types.hpp:674
pcl::_Normal::curvature
float curvature
Definition: point_types.hpp:801
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA(const _PointXYZRGBA &p)
Definition: point_types.hpp:555
pcl_macros.h
Defines all the PCL and non-PCL macros used.
pcl::PFHSignature125
A point structure representing the Point Feature Histogram (PFH).
Definition: point_types.hpp:1264
pcl
Definition: convolution.h:46
pcl::_PointXYZL::label
std::uint32_t label
Definition: point_types.hpp:488
pcl::PointWithRange::PointWithRange
PointWithRange(float _x, float _y, float _z, float _range=0.f)
Definition: point_types.hpp:1126
pcl::Label::label
std::uint32_t label
Definition: point_types.hpp:517
pcl::PointDEM
A point structure representing Digital Elevation Map.
Definition: point_types.hpp:1790
pcl::_Axis::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:837
point_types.h
pcl::Normal
A point structure representing normal coordinates and the surface curvature estimate.
Definition: point_types.hpp:812
pcl::VFHSignature308::operator<<
friend std::ostream & operator<<(std::ostream &os, const VFHSignature308 &p)
pcl::GRSDSignature21::histogram
float histogram[21]
Definition: point_types.hpp:1506
pcl::PrincipalRadiiRSD
A point structure representing the minimum and maximum surface radii (in meters) computed using RSD.
Definition: point_types.hpp:1198
pcl::Axis::Axis
Axis(float n_x, float n_y, float n_z)
Definition: point_types.hpp:855
pcl::_PointWithRange::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1100
pcl::PointXYZL::PointXYZL
PointXYZL(std::uint32_t _label=0)
Definition: point_types.hpp:501
pcl::_ReferenceFrame::getYAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getYAxisVector3fMap() const
Definition: point_types.hpp:1441
pcl::PointXYZI::PointXYZI
PointXYZI(const _PointXYZI &p)
Definition: point_types.hpp:466
pcl::IntensityGradient::gradient_x
float gradient_x
Definition: point_types.hpp:1651
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA()
Definition: point_types.hpp:561
pcl::PPFRGBSignature
A point structure for storing the Point Pair Color Feature (PPFRGB) values.
Definition: point_types.hpp:1329
pcl::PointUV::PointUV
PointUV()=default
pcl::PPFRGBSignature::f1
float f1
Definition: point_types.hpp:1331
pcl::IntensityGradient::gradient_z
float gradient_z
Definition: point_types.hpp:1653
pcl::GASDSignature7992::histogram
float histogram[7992]
Definition: point_types.hpp:1580
pcl::PointSurfel::PointSurfel
PointSurfel()
Definition: point_types.hpp:1762
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint32_t _label=0)
Definition: point_types.hpp:677
pcl::_PointWithScale::scale
float scale
Diameter of the meaningful keypoint neighborhood.
Definition: point_types.hpp:1682
pcl::ESFSignature640::operator<<
friend std::ostream & operator<<(std::ostream &os, const ESFSignature640 &p)
pcl::_Intensity32u::PCL_ADD_INTENSITY_32U
PCL_ADD_INTENSITY_32U
Definition: point_types.hpp:423
pcl::GASDSignature7992::GASDSignature7992
GASDSignature7992()=default
pcl::PointXY::PointXY
PointXY(float _x, float _y)
Definition: point_types.hpp:751
pcl::PointUV::u
float u
Definition: point_types.hpp:763
pcl::Vector3c
Eigen::Matrix< std::uint8_t, 3, 1 > Vector3c
Definition: point_types.hpp:185
pcl::PrincipalRadiiRSD::PrincipalRadiiRSD
PrincipalRadiiRSD()=default
pcl::ShapeContext1980::operator<<
friend std::ostream & operator<<(std::ostream &os, const ShapeContext1980 &p)
pcl::CPPFSignature::operator<<
friend std::ostream & operator<<(std::ostream &os, const CPPFSignature &p)
pcl::PointUV::v
float v
Definition: point_types.hpp:764
pcl::SHOT1344::rf
float rf[9]
Definition: point_types.hpp:1413
pcl::PointSurfel
A surfel, that is, a point structure representing Euclidean xyz coordinates, together with normal coo...
Definition: point_types.hpp:1751
pcl::NormalBasedSignature12::values
float values[12]
Definition: point_types.hpp:1353
pcl::CPPFSignature::f5
float f5
Definition: point_types.hpp:1311
pcl::_PointXYZRGBL::PCL_ADD_RGB
PCL_ADD_RGB
Definition: point_types.hpp:591
pcl::NormalBasedSignature12
A point structure representing the Normal Based Signature for a feature matrix of 4-by-3.
Definition: point_types.hpp:1351
pcl::GFPFHSignature16::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1595
pcl::_PointXYZRGB::PCL_ADD_RGB
PCL_ADD_RGB
Definition: point_types.hpp:584
pcl::MomentInvariants::j2
float j2
Definition: point_types.hpp:1185
pcl::UniqueShapeContext1960::descriptor
float descriptor[1960]
Definition: point_types.hpp:1381
pcl::GASDSignature512::GASDSignature512
GASDSignature512()=default
POINT_CLOUD_REGISTER_POINT_STRUCT
POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::_PointXYZLAB,(float, x, x)(float, y, y)(float, z, z)(float, L, L)(float, a, a)(float, b, b)) namespace pcl
Definition: gicp6d.h:79
pcl::GASDSignature512
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor.
Definition: point_types.hpp:1550
pcl::CPPFSignature::f10
float f10
Definition: point_types.hpp:1311
pcl::InterestPoint::strength
float strength
Definition: point_types.hpp:785
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA(float _x, float _y, float _z)
Definition: point_types.hpp:566
pcl::_PointNormal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:869
pcl::PointDEM::PointDEM
PointDEM(const _PointDEM &p)
Definition: point_types.hpp:1792
pcl::_PointDEM::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1779
pcl::Histogram::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1672
pcl::PrincipalRadiiRSD::r_min
float r_min
Definition: point_types.hpp:1200
pcl::_PointSurfel::confidence
float confidence
Definition: point_types.hpp:1738
pcl::PPFRGBSignature::f2
float f2
Definition: point_types.hpp:1331
pcl::PointXYZL::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZL &p)
pcl::_ReferenceFrame::getYAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getYAxisVector3fMap()
Definition: point_types.hpp:1440
pcl::InterestPoint::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:780
pcl::_PointWithViewpoint::vp_x
float vp_x
Definition: point_types.hpp:1144
pcl::_PointXYZ::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:291
pcl::GASDSignature512::operator<<
friend std::ostream & operator<<(std::ostream &os, const GASDSignature512 &p)
pcl::PFHSignature125::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1267
pcl::VFHSignature308::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1493
pcl::RGB::RGB
RGB()
Definition: point_types.hpp:352
pcl::_PointXYZINormal::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:998
pcl::PointXYZRGBL
Definition: point_types.hpp:659
pcl::CPPFSignature::f4
float f4
Definition: point_types.hpp:1311
pcl::Narf36::z
float z
Definition: point_types.hpp:1608
pcl::ReferenceFrame
Definition: point_types.hpp:1451
pcl::PFHSignature125::PFHSignature125
PFHSignature125()=default
pcl::Boundary
A point structure representing a description of whether a point is lying on a surface boundary or not...
Definition: point_types.hpp:1213
pcl::CPPFSignature::f7
float f7
Definition: point_types.hpp:1311
pcl::ShapeContext1980::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1368
pcl::PCLPointField::count
uindex_t count
Definition: PCLPointField.h:18
pcl::ESFSignature640::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1539
pcl::_PointWithScale::angle
float angle
Computed orientation of the keypoint (-1 if not applicable).
Definition: point_types.hpp:1687
pcl::MomentInvariants::MomentInvariants
MomentInvariants(float _j1, float _j2, float _j3)
Definition: point_types.hpp:1189
pcl::RGB::operator<<
friend std::ostream & operator<<(std::ostream &os, const RGB &p)
pcl::PointXYZI
Definition: point_types.hpp:464
pcl::NormalBasedSignature12::NormalBasedSignature12
NormalBasedSignature12()=default
pcl::PPFRGBSignature::f3
float f3
Definition: point_types.hpp:1331
pcl::_PointXYZINormal::intensity
float intensity
Definition: point_types.hpp:1004
pcl::FPFHSignature33
A point structure representing the Fast Point Feature Histogram (FPFH).
Definition: point_types.hpp:1476
pcl::UniqueShapeContext1960::rf
float rf[9]
Definition: point_types.hpp:1382
pcl::_PointDEM::height_variance
float height_variance
Definition: point_types.hpp:1782
pcl::UniqueShapeContext1960::operator<<
friend std::ostream & operator<<(std::ostream &os, const UniqueShapeContext1960 &p)
pcl::Narf36::pitch
float pitch
Definition: point_types.hpp:1608
pcl::BRISKSignature512::descriptor
unsigned char descriptor[64]
Definition: point_types.hpp:1522
pcl::_PointXYZRGBNormal::PCL_ADD_UNION_RGB
PCL_ADD_UNION_RGB
Definition: point_types.hpp:920
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:978
pcl::Histogram::histogram
float histogram[N]
Definition: point_types.hpp:1671
pcl::Boundary::operator<<
friend std::ostream & operator<<(std::ostream &os, const Boundary &p)
pcl::Axis::Axis
Axis(const _Axis &p)
Definition: point_types.hpp:847
pcl::PointWithRange::PointWithRange
PointWithRange(float _range=0.f)
Definition: point_types.hpp:1124
pcl::SHOT1344::operator<<
friend std::ostream & operator<<(std::ostream &os, const SHOT1344 &p)
pcl::PFHSignature125::operator<<
friend std::ostream & operator<<(std::ostream &os, const PFHSignature125 &p)
pcl::GRSDSignature21::operator<<
friend std::ostream & operator<<(std::ostream &os, const GRSDSignature21 &p)
pcl::SHOT352::operator<<
friend std::ostream & operator<<(std::ostream &os, const SHOT352 &p)
pcl::PointXYZINormal
A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates...
Definition: point_types.hpp:1016
pcl::Narf36::y
float y
Definition: point_types.hpp:1608
pcl::PrincipalCurvatures::principal_curvature_z
float principal_curvature_z
Definition: point_types.hpp:1242
pcl::_PointSurfel::radius
float radius
Definition: point_types.hpp:1737
pcl::PrincipalCurvatures::principal_curvature
float principal_curvature[3]
Definition: point_types.hpp:1237
pcl::Intensity8u
A point structure representing the grayscale intensity in single-channel images.
Definition: point_types.hpp:399
pcl::GASDSignature984::GASDSignature984
GASDSignature984()=default
pcl::PrincipalCurvatures::PrincipalCurvatures
PrincipalCurvatures(float _x, float _y, float _z, float _pc1, float _pc2)
Definition: point_types.hpp:1254
pcl::_ReferenceFrame::getZAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getZAxisVector3fMap() const
Definition: point_types.hpp:1443
pcl::_Normal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:796
pcl::PointWithScale::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointWithScale &p)
pcl::RGB::RGB
RGB(const _RGB &p)
Definition: point_types.hpp:347
pcl::Narf36::roll
float roll
Definition: point_types.hpp:1608
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB()
Definition: point_types.hpp:636
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:981
pcl::SHOT1344::descriptor
float descriptor[1344]
Definition: point_types.hpp:1412
pcl::SHOT1344::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1414
pcl::PointXYZRGB
A point structure representing Euclidean xyz coordinates, and the RGB color.
Definition: point_types.hpp:628
pcl::FieldMatches::operator()
bool operator()(const PCLPointField &field)
Definition: PCLPointField.h:55
pcl::PointXYZHSV::PointXYZHSV
PointXYZHSV()
Definition: point_types.hpp:718
pcl::PPFRGBSignature::PPFRGBSignature
PPFRGBSignature(float _f1, float _f2, float _f3, float _f4, float _alpha=0.f)
Definition: point_types.hpp:1337
pcl::Vector3cMap
Eigen::Map< Vector3c > Vector3cMap
Definition: point_types.hpp:186
pcl::PointWithViewpoint::PointWithViewpoint
PointWithViewpoint(float _x, float _y, float _z, float _vp_x, float _vp_y, float _vp_z)
Definition: point_types.hpp:1169
pcl::UniqueShapeContext1960
A point structure representing a Unique Shape Context.
Definition: point_types.hpp:1379
pcl::PrincipalCurvatures::pc2
float pc2
Definition: point_types.hpp:1246
pcl::PCLPointField::FLOAT32
@ FLOAT32
Definition: PCLPointField.h:26
pcl::PointNormal::PointNormal
PointNormal(const _PointNormal &p)
Definition: point_types.hpp:887
pcl::PointDEM::PointDEM
PointDEM(float _x, float _y, float _z)
Definition: point_types.hpp:1802
pcl::PointWithViewpoint
A point structure representing Euclidean xyz coordinates together with the viewpoint from which it wa...
Definition: point_types.hpp:1157
pcl::_PointXYZI
A point structure representing Euclidean xyz coordinates, and the intensity value.
Definition: point_types.hpp:449
pcl::PCLPointField::UINT32
@ UINT32
Definition: PCLPointField.h:25
pcl::FPFHSignature33::operator<<
friend std::ostream & operator<<(std::ostream &os, const FPFHSignature33 &p)
pcl::PrincipalRadiiRSD::PrincipalRadiiRSD
PrincipalRadiiRSD(float _r_min, float _r_max)
Definition: point_types.hpp:1204
pcl::MomentInvariants::j1
float j1
Definition: point_types.hpp:1185
pcl::BorderDescription::operator<<
friend std::ostream & operator<<(std::ostream &os, const BorderDescription &p)
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(float _x, float _y, float _z)
Definition: point_types.hpp:972
pcl::_ReferenceFrame::getXAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getXAxisVector3fMap() const
Definition: point_types.hpp:1439
pcl::_PointSurfel::curvature
float curvature
Definition: point_types.hpp:1739
pcl::Intensity
A point structure representing the grayscale intensity in single-channel images.
Definition: point_types.hpp:373
pcl::_PointWithScale::octave
int octave
octave (pyramid layer) from which the keypoint has been extracted.
Definition: point_types.hpp:1691
pcl::GASDSignature512::histogram
float histogram[512]
Definition: point_types.hpp:1552
pcl::_PointXYZI::intensity
float intensity
Definition: point_types.hpp:456
pcl::_PointWithViewpoint
Definition: point_types.hpp:1137
pcl::ShapeContext1980::descriptor
float descriptor[1980]
Definition: point_types.hpp:1366
pcl::Narf36::Narf36
Narf36(float _x, float _y, float _z)
Definition: point_types.hpp:1614
pcl::PointXYZHSV
Definition: point_types.hpp:710
pcl::PointXY::x
float x
Definition: point_types.hpp:746
pcl::Intensity::Intensity
Intensity(const _Intensity &p)
Definition: point_types.hpp:375
pcl::ShapeContext1980
A point structure representing a Shape Context.
Definition: point_types.hpp:1364
pcl::PointXYZINormal::PointXYZINormal
PointXYZINormal(float _intensity=0.f)
Definition: point_types.hpp:1026
pcl::_PointSurfel::PCL_ADD_UNION_RGB
PCL_ADD_UNION_RGB
Definition: point_types.hpp:1736
pcl::Intensity32u::operator<<
friend std::ostream & operator<<(std::ostream &os, const Intensity32u &p)
pcl::GFPFHSignature16
A point structure representing the GFPFH descriptor with 16 bins.
Definition: point_types.hpp:1592
pcl::PCLPointField::datatype
std::uint8_t datatype
Definition: PCLPointField.h:17
pcl::NormalBasedSignature12::operator<<
friend std::ostream & operator<<(std::ostream &os, const NormalBasedSignature12 &p)
pcl::operator<<
std::ostream & operator<<(std::ostream &os, const BivariatePolynomialT< real > &p)
Definition: bivariate_polynomial.hpp:240
pcl::Intensity8u::Intensity8u
Intensity8u(std::uint8_t _intensity=0)
Definition: point_types.hpp:406
pcl::PointSurfel::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointSurfel &p)
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:638
pcl::Intensity8u::operator<<
friend std::ostream & operator<<(std::ostream &os, const Intensity8u &p)
pcl::PFHRGBSignature250::PFHRGBSignature250
PFHRGBSignature250()=default
pcl::Array3fMap
Eigen::Map< Eigen::Array3f > Array3fMap
Definition: point_types.hpp:176
pcl::GASDSignature7992
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descr...
Definition: point_types.hpp:1578
pcl::BRISKSignature512::operator<<
friend std::ostream & operator<<(std::ostream &os, const BRISKSignature512 &p)
pcl::GASDSignature7992::operator<<
friend std::ostream & operator<<(std::ostream &os, const GASDSignature7992 &p)
pcl::PointXYZRGBA
A point structure representing Euclidean xyz coordinates, and the RGBA color.
Definition: point_types.hpp:553
pcl::_Normal
Definition: point_types.hpp:794
pcl::PrincipalCurvatures::pc1
float pc1
Definition: point_types.hpp:1245
pcl::_PointXYZRGBNormal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:915
pcl::PointXYZHSV::PointXYZHSV
PointXYZHSV(const _PointXYZHSV &p)
Definition: point_types.hpp:712
pcl::PointXY::y
float y
Definition: point_types.hpp:747
pcl::CPPFSignature::alpha_m
float alpha_m
Definition: point_types.hpp:1312
pcl::_PointXYZHSV::s
float s
Definition: point_types.hpp:701
pcl::PointUV::PointUV
PointUV(float _u, float _v)
Definition: point_types.hpp:768
pcl::_PointWithViewpoint::vp_z
float vp_z
Definition: point_types.hpp:1146
pcl::_PointXYZRGBL::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:590
pcl::_Axis
Definition: point_types.hpp:835
pcl::PointXYZL::PointXYZL
PointXYZL(const _PointXYZL &p)
Definition: point_types.hpp:495
pcl::PrincipalCurvatures::operator<<
friend std::ostream & operator<<(std::ostream &os, const PrincipalCurvatures &p)
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(const _PointXYZRGBL &p)
Definition: point_types.hpp:661
pcl::GASDSignature7992::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1581
pcl::_PointXYZLNormal::curvature
float curvature
Definition: point_types.hpp:1055
pcl::BorderDescription::y
int y
Definition: point_types.hpp:1628
pcl::_PointWithViewpoint::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1139
pcl::_PointWithRange::range
float range
Definition: point_types.hpp:1105
pcl::ShapeContext1980::rf
float rf[9]
Definition: point_types.hpp:1367
pcl::BRISKSignature512::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1523
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:644
pcl::GRSDSignature21
A point structure representing the Global Radius-based Surface Descriptor (GRSD).
Definition: point_types.hpp:1504
pcl::PointXYZ
A point structure representing Euclidean xyz coordinates.
Definition: point_types.hpp:300
pcl::_Intensity32u
Definition: point_types.hpp:421
pcl::PPFRGBSignature::PPFRGBSignature
PPFRGBSignature(float _f1, float _f2, float _f3, float _f4, float _alpha, float _r, float _g, float _b)
Definition: point_types.hpp:1340
pcl::CPPFSignature
A point structure for storing the Point Pair Feature (CPPF) values.
Definition: point_types.hpp:1309
pcl::PPFSignature::f1
float f1
Definition: point_types.hpp:1294
pcl::PointXYZINormal::PointXYZINormal
PointXYZINormal(float _x, float _y, float _z, float _intensity=0.f)
Definition: point_types.hpp:1028
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:671
pcl::_PointXYZLNormal::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1048
pcl::_Intensity8u
Definition: point_types.hpp:389
pcl::Intensity32u
A point structure representing the grayscale intensity in single-channel images.
Definition: point_types.hpp:431
pcl::PointXYZINormal::PointXYZINormal
PointXYZINormal(const _PointXYZINormal &p)
Definition: point_types.hpp:1018
pcl::Label
Definition: point_types.hpp:515
pcl::_PointXYZRGBNormal::curvature
float curvature
Definition: point_types.hpp:921
pcl::PPFSignature
A point structure for storing the Point Pair Feature (PPF) values.
Definition: point_types.hpp:1292
pcl::CPPFSignature::f3
float f3
Definition: point_types.hpp:1311
pcl::_Intensity
Definition: point_types.hpp:363
pcl::Vector4cMapConst
const Eigen::Map< const Vector4c, Eigen::Aligned > Vector4cMapConst
Definition: point_types.hpp:190
pcl::PointXYZLNormal::PointXYZLNormal
PointXYZLNormal(float _x, float _y, float _z, std::uint32_t _label=0.f)
Definition: point_types.hpp:1078
pcl::PointXYZLNormal::PointXYZLNormal
PointXYZLNormal(const _PointXYZLNormal &p)
Definition: point_types.hpp:1068
pcl::_ReferenceFrame::getZAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getZAxisVector3fMap()
Definition: point_types.hpp:1442
pcl::PointWithViewpoint::PointWithViewpoint
PointWithViewpoint()
Definition: point_types.hpp:1165
pcl::GASDSignature984::operator<<
friend std::ostream & operator<<(std::ostream &os, const GASDSignature984 &p)
pcl::PrincipalCurvatures::principal_curvature_y
float principal_curvature_y
Definition: point_types.hpp:1241
pcl::IntensityGradient::gradient
float gradient[3]
Definition: point_types.hpp:1648
pcl::_PointDEM::intensity
float intensity
Definition: point_types.hpp:1780
pcl::PrincipalRadiiRSD::r_max
float r_max
Definition: point_types.hpp:1200
pcl::_PointXYZRGBNormal::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:914
pcl::ShapeContext1980::ShapeContext1980
ShapeContext1980()=default
pcl::Array4fMap
Eigen::Map< Eigen::Array4f, Eigen::Aligned > Array4fMap
Definition: point_types.hpp:178
pcl::PointXYZL
Definition: point_types.hpp:493
pcl::PPFSignature::PPFSignature
PPFSignature(float _alpha=0.f)
Definition: point_types.hpp:1297
pcl::PointXYZI::PointXYZI
PointXYZI(float _x, float _y, float _z, float _intensity=0.f)
Definition: point_types.hpp:474
pcl::CPPFSignature::CPPFSignature
CPPFSignature(float _alpha=0.f)
Definition: point_types.hpp:1314
pcl::_PointXYZHSV::h
float h
Definition: point_types.hpp:700
pcl::_RGB::PCL_ADD_RGB
PCL_ADD_RGB
Definition: point_types.hpp:322
pcl::BRISKSignature512
A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK).
Definition: point_types.hpp:1518
pcl::_PointXYZRGBA::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:527
pcl::Array4fMapConst
const Eigen::Map< const Eigen::Array4f, Eigen::Aligned > Array4fMapConst
Definition: point_types.hpp:179
pcl::Axis
A point structure representing an Axis using its normal coordinates.
Definition: point_types.hpp:845
pcl::PointXYZLNormal::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZLNormal &p)
pcl::PointWithScale::PointWithScale
PointWithScale(const _PointWithScale &p)
Definition: point_types.hpp:1702
pcl::_PointXYZRGB
Definition: point_types.hpp:581
PCL_MAKE_ALIGNED_OPERATOR_NEW
#define PCL_MAKE_ALIGNED_OPERATOR_NEW
Macro to signal a class requires a custom allocator.
Definition: memory.h:63
pcl::VFHSignature308::histogram
float histogram[308]
Definition: point_types.hpp:1492
pcl::RGB
A structure representing RGB color information.
Definition: point_types.hpp:345
pcl::PointXYZ::PointXYZ
PointXYZ(float _x, float _y, float _z)
Definition: point_types.hpp:306
pcl::FPFHSignature33::histogram
float histogram[33]
Definition: point_types.hpp:1478
pcl::Intensity8u::Intensity8u
Intensity8u(const _Intensity8u &p)
Definition: point_types.hpp:401
pcl::SHOT1344::SHOT1344
SHOT1344()=default
pcl::PFHRGBSignature250
A point structure representing the Point Feature Histogram with colors (PFHRGB).
Definition: point_types.hpp:1278
pcl::SHOT352::rf
float rf[9]
Definition: point_types.hpp:1397
pcl::PointXYZ::PointXYZ
PointXYZ()
Definition: point_types.hpp:304
pcl::MomentInvariants
A point structure representing the three moment invariants.
Definition: point_types.hpp:1183
pcl::_PointWithScale::size
float size
Definition: point_types.hpp:1683
pcl::InterestPoint
A point structure representing an interest point with Euclidean xyz coordinates, and an interest valu...
Definition: point_types.hpp:778
pcl::Normal::Normal
Normal(float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:823
pcl::BRISKSignature512::BRISKSignature512
BRISKSignature512(float _scale, float _orientation)
Definition: point_types.hpp:1527
pcl::PointDEM::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointDEM &p)
pcl::_PointWithViewpoint::vp_y
float vp_y
Definition: point_types.hpp:1145
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
Definition: point_types.hpp:569
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB(const _PointXYZRGB &p)
Definition: point_types.hpp:630
pcl::_PointXYZLNormal::label
std::uint32_t label
Definition: point_types.hpp:1054
pcl::PPFSignature::PPFSignature
PPFSignature(float _f1, float _f2, float _f3, float _f4, float _alpha=0.f)
Definition: point_types.hpp:1299
pcl::PFHRGBSignature250::operator<<
friend std::ostream & operator<<(std::ostream &os, const PFHRGBSignature250 &p)
pcl::PointNormal
A point structure representing Euclidean xyz coordinates, together with normal coordinates and the su...
Definition: point_types.hpp:885
pcl::Narf36::x
float x
Definition: point_types.hpp:1608
pcl::_PointXYZL::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:487
pcl::PointXYZI::PointXYZI
PointXYZI(float _intensity=0.f)
Definition: point_types.hpp:472
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(float _curvature=0.f)
Definition: point_types.hpp:969
pcl::IntensityGradient::gradient_y
float gradient_y
Definition: point_types.hpp:1652
pcl::_PointXYZHSV
Definition: point_types.hpp:693
pcl::_PointXYZRGBL::label
std::uint32_t label
Definition: point_types.hpp:592
pcl::PrincipalCurvatures::principal_curvature_x
float principal_curvature_x
Definition: point_types.hpp:1240
pcl::_PointXYZ
Definition: point_types.hpp:289
pcl::PointNormal::PointNormal
PointNormal(float _x, float _y, float _z)
Definition: point_types.hpp:896
pcl::Narf36::Narf36
Narf36(float _x, float _y, float _z, float _roll, float _pitch, float _yaw)
Definition: point_types.hpp:1616
pcl::PointXY
A 2D point structure representing Euclidean xy coordinates.
Definition: point_types.hpp:744
pcl::PointXY::PointXY
PointXY()=default
pcl::PointXYZHSV::PointXYZHSV
PointXYZHSV(float _x, float _y, float _z, float _h, float _s, float _v)
Definition: point_types.hpp:725
pcl::PrincipalRadiiRSD::operator<<
friend std::ostream & operator<<(std::ostream &os, const PrincipalRadiiRSD &p)
pcl::Axis::Axis
Axis()
Definition: point_types.hpp:853
pcl::GASDSignature512::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1553
pcl::PPFRGBSignature::r_ratio
float r_ratio
Definition: point_types.hpp:1332
pcl::_PointWithRange
Definition: point_types.hpp:1098
pcl::_PointXYZRGB::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:583
pcl::_PointXYZLNormal
Definition: point_types.hpp:1046
pcl::_RGB
Definition: point_types.hpp:320
pcl::ESFSignature640::histogram
float histogram[640]
Definition: point_types.hpp:1538
pcl::PointXYZINormal::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZINormal &p)
pcl::PointXYZLNormal::PointXYZLNormal
PointXYZLNormal(float _x, float _y, float _z, std::uint32_t _label, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:1081
pcl::Label::operator<<
friend std::ostream & operator<<(std::ostream &os, const Label &p)
pcl::PointDEM::PointDEM
PointDEM(float _x, float _y, float _z, float _intensity, float _intensity_variance, float _height_variance)
Definition: point_types.hpp:1804
pcl::ReferenceFrame::ReferenceFrame
ReferenceFrame()
Definition: point_types.hpp:1458
pcl::Narf36::operator<<
friend std::ostream & operator<<(std::ostream &os, const Narf36 &p)
pcl::BorderTraits
std::bitset< 32 > BorderTraits
Data type to store extended information about a transition from foreground to backgroundSpecification...
Definition: point_types.h:302
pcl::_PointXYZINormal
Definition: point_types.hpp:996
pcl::IntensityGradient::IntensityGradient
IntensityGradient()
Definition: point_types.hpp:1657
pcl::PrincipalCurvatures
A point structure representing the principal curvatures and their magnitudes.
Definition: point_types.hpp:1233
pcl::PointXYZ::PointXYZ
PointXYZ(const _PointXYZ &p)
Definition: point_types.hpp:302
pcl::Normal::Normal
Normal(const _Normal &p)
Definition: point_types.hpp:814
pcl::_PointXYZI::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:451
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB(float _x, float _y, float _z)
Definition: point_types.hpp:641
pcl::Narf36
A point structure representing the Narf descriptor.
Definition: point_types.hpp:1606
pcl::PointXY::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXY &p)
pcl::GFPFHSignature16::histogram
float histogram[16]
Definition: point_types.hpp:1594
pcl::_Intensity8u::PCL_ADD_INTENSITY_8U
PCL_ADD_INTENSITY_8U
Definition: point_types.hpp:391
pcl::PointXYZL::PointXYZL
PointXYZL(float _x, float _y, float _z, std::uint32_t _label=0)
Definition: point_types.hpp:503
pcl::SHOT352::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1398
pcl::_PointXYZRGBL
Definition: point_types.hpp:588
pcl::_PointWithScale::response
float response
The response by which the most strong keypoints have been selected.
Definition: point_types.hpp:1689
pcl::Vector3fMapConst
const Eigen::Map< const Eigen::Vector3f > Vector3fMapConst
Definition: point_types.hpp:181
pcl::Narf36::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1610
pcl::PointNormal::PointNormal
PointNormal(float _curvature=0.f)
Definition: point_types.hpp:894
pcl::GRSDSignature21::GRSDSignature21
GRSDSignature21()=default
pcl::ESFSignature640
A point structure representing the Ensemble of Shape Functions (ESF).
Definition: point_types.hpp:1536
pcl::PPFRGBSignature::PPFRGBSignature
PPFRGBSignature(float _alpha=0.f)
Definition: point_types.hpp:1335
pcl::GFPFHSignature16::operator<<
friend std::ostream & operator<<(std::ostream &os, const GFPFHSignature16 &p)
pcl::PointWithScale
A point structure representing a 3-D position and scale.
Definition: point_types.hpp:1700
pcl::PFHRGBSignature250::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1281
pcl::CPPFSignature::f1
float f1
Definition: point_types.hpp:1311
pcl::PointWithScale::PointWithScale
PointWithScale()
Definition: point_types.hpp:1711
pcl::_PointSurfel::PCL_ADD_EIGEN_MAPS_RGB
PCL_ADD_EIGEN_MAPS_RGB
Definition: point_types.hpp:1743
pcl::PPFSignature::f2
float f2
Definition: point_types.hpp:1294
pcl::BRISKSignature512::scale
float scale
Definition: point_types.hpp:1520
pcl::_PointXYZRGBA::PCL_ADD_RGB
PCL_ADD_RGB
Definition: point_types.hpp:528
pcl::PPFRGBSignature::alpha_m
float alpha_m
Definition: point_types.hpp:1333
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
Definition: point_types.hpp:563
pcl::_PointNormal::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:868
pcl::_PointNormal
Definition: point_types.hpp:866
pcl::GASDSignature984
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descr...
Definition: point_types.hpp:1564
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(std::uint32_t _label=0)
Definition: point_types.hpp:668
pcl::_Intensity::PCL_ADD_INTENSITY
PCL_ADD_INTENSITY
Definition: point_types.hpp:365
pcl::PointWithRange
A point structure representing Euclidean xyz coordinates, padded with an extra range float.
Definition: point_types.hpp:1116
pcl::Histogram
A point structure representing an N-D histogram.
Definition: point_types.hpp:1669
pcl::PointNormal::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointNormal &p)
pcl::PPFRGBSignature::b_ratio
float b_ratio
Definition: point_types.hpp:1332
pcl::ReferenceFrame::ReferenceFrame
ReferenceFrame(const _ReferenceFrame &p)
Definition: point_types.hpp:1453
pcl::MomentInvariants::j3
float j3
Definition: point_types.hpp:1185
pcl::UniqueShapeContext1960::UniqueShapeContext1960
UniqueShapeContext1960()=default
pcl::_PointXYZRGBNormal::PCL_ADD_EIGEN_MAPS_RGB
PCL_ADD_EIGEN_MAPS_RGB
Definition: point_types.hpp:925
pcl::PCLPointField::name
std::string name
Definition: PCLPointField.h:14
pcl::BRISKSignature512::BRISKSignature512
BRISKSignature512()=default
pcl::_ReferenceFrame::getXAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getXAxisVector3fMap()
Definition: point_types.hpp:1438
pcl::Boundary::boundary_point
std::uint8_t boundary_point
Definition: point_types.hpp:1215
pcl::PrincipalCurvatures::PrincipalCurvatures
PrincipalCurvatures()
Definition: point_types.hpp:1248
pcl::PointWithRange::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointWithRange &p)
pcl::Intensity32u::Intensity32u
Intensity32u(std::uint32_t _intensity=0)
Definition: point_types.hpp:438
pcl::_PointXYZHSV::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:695
pcl::Normal::operator<<
friend std::ostream & operator<<(std::ostream &os, const Normal &p)
pcl::PointXYZRGBNormal
A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coo...
Definition: point_types.hpp:959
pcl::Vector4c
Eigen::Matrix< std::uint8_t, 4, 1 > Vector4c
Definition: point_types.hpp:188
pcl::Vector3cMapConst
const Eigen::Map< const Vector3c > Vector3cMapConst
Definition: point_types.hpp:187
pcl::PPFSignature::alpha_m
float alpha_m
Definition: point_types.hpp:1295
pcl::_PointXYZRGBA
Definition: point_types.hpp:525
pcl::_ReferenceFrame::rf
float rf[9]
Definition: point_types.hpp:1429
pcl::PointXYZI::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZI &p)
pcl::_PointNormal::curvature
float curvature
Definition: point_types.hpp:874
pcl::GASDSignature984::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1567
pcl::UniqueShapeContext1960::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1383
pcl::PointXYZLNormal
A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates a...
Definition: point_types.hpp:1066
pcl::BorderDescription
A structure to store if a point in a range image lies on a border between an obstacle and the backgro...
Definition: point_types.hpp:1626
pcl::CPPFSignature::f9
float f9
Definition: point_types.hpp:1311
pcl::CPPFSignature::f6
float f6
Definition: point_types.hpp:1311
pcl::SHOT352::descriptor
float descriptor[352]
Definition: point_types.hpp:1396
pcl::FPFHSignature33::FPFHSignature33
FPFHSignature33()=default
pcl::Boundary::Boundary
Boundary(std::uint8_t _boundary=0)
Definition: point_types.hpp:1224
pcl::BorderDescription::BorderDescription
BorderDescription()=default
pcl::BRISKSignature512::orientation
float orientation
Definition: point_types.hpp:1521
pcl::SHOT1344
A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+col...
Definition: point_types.hpp:1410
pcl::PCLPointField
Definition: PCLPointField.h:12
pcl::MomentInvariants::operator<<
friend std::ostream & operator<<(std::ostream &os, const MomentInvariants &p)
pcl::PointXYZLNormal::PointXYZLNormal
PointXYZLNormal(std::uint32_t _label=0)
Definition: point_types.hpp:1076
pcl::PrincipalCurvatures::PrincipalCurvatures
PrincipalCurvatures(float _x, float _y, float _z)
Definition: point_types.hpp:1252
pcl::PointXYZINormal::PointXYZINormal
PointXYZINormal(float _x, float _y, float _z, float _intensity, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:1031
pcl::PPFRGBSignature::f4
float f4
Definition: point_types.hpp:1331
pcl::SHOT352
A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape onl...
Definition: point_types.hpp:1394
pcl::PPFRGBSignature::operator<<
friend std::ostream & operator<<(std::ostream &os, const PPFRGBSignature &p)
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:975
pcl::_PointSurfel
Definition: point_types.hpp:1728
pcl::Vector3fMap
Eigen::Map< Eigen::Vector3f > Vector3fMap
Definition: point_types.hpp:180
pcl::_ReferenceFrame::getMatrix3fMap
const Eigen::Map< const Eigen::Matrix3f > getMatrix3fMap() const
Definition: point_types.hpp:1445
pcl::GFPFHSignature16::GFPFHSignature16
GFPFHSignature16()=default
pcl::BorderDescription::x
int x
Definition: point_types.hpp:1628
pcl::PPFRGBSignature::g_ratio
float g_ratio
Definition: point_types.hpp:1332
pcl::PPFSignature::operator<<
friend std::ostream & operator<<(std::ostream &os, const PPFSignature &p)
pcl::_PointXYZINormal::curvature
float curvature
Definition: point_types.hpp:1005
pcl::PointXYZRGBNormal::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZRGBNormal &p)
pcl::BorderDescription::traits
BorderTraits traits
Definition: point_types.hpp:1629
pcl::PPFSignature::f4
float f4
Definition: point_types.hpp:1294
pcl::RGB::RGB
RGB(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:354
pcl::_PointDEM
Definition: point_types.hpp:1777
pcl::_PointSurfel::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:1731
pcl::Narf36::yaw
float yaw
Definition: point_types.hpp:1608
pcl::Vector4fMap
Eigen::Map< Eigen::Vector4f, Eigen::Aligned > Vector4fMap
Definition: point_types.hpp:182
pcl::Normal::Normal
Normal(float _curvature=0.f)
Definition: point_types.hpp:821
pcl::IntensityGradient::operator<<
friend std::ostream & operator<<(std::ostream &os, const IntensityGradient &p)
pcl::PointWithRange::PointWithRange
PointWithRange(const _PointWithRange &p)
Definition: point_types.hpp:1118
pcl::PointDEM::PointDEM
PointDEM()
Definition: point_types.hpp:1800
pcl::VFHSignature308::VFHSignature308
VFHSignature308()=default
pcl::Vector4cMap
Eigen::Map< Vector4c, Eigen::Aligned > Vector4cMap
Definition: point_types.hpp:189
pcl::GASDSignature984::histogram
float histogram[984]
Definition: point_types.hpp:1566
pcl::PointWithViewpoint::PointWithViewpoint
PointWithViewpoint(const _PointWithViewpoint &p)
Definition: point_types.hpp:1159
pcl::MomentInvariants::MomentInvariants
MomentInvariants()=default
pcl::_PointXYZLNormal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:1049
pcl::_PointXYZINormal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:999
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(const _PointXYZRGBNormal &p)
Definition: point_types.hpp:961
pcl::IntensityGradient::IntensityGradient
IntensityGradient(float _x, float _y, float _z)
Definition: point_types.hpp:1659
pcl::_PointWithScale
Definition: point_types.hpp:1675
pcl::PFHSignature125::histogram
float histogram[125]
Definition: point_types.hpp:1266
pcl::PointNormal::PointNormal
PointNormal(float _x, float _y, float _z, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:899
pcl::_PointXYZHSV::v
float v
Definition: point_types.hpp:702
pcl::PointXYZHSV::PointXYZHSV
PointXYZHSV(float _h, float _s, float _v)
Definition: point_types.hpp:722
pcl::_ReferenceFrame::getMatrix3fMap
Eigen::Map< Eigen::Matrix3f > getMatrix3fMap()
Definition: point_types.hpp:1444
pcl::FPFHSignature33::descriptorSize
static int descriptorSize()
Definition: point_types.hpp:1479
pcl::Array3fMapConst
const Eigen::Map< const Eigen::Array3f > Array3fMapConst
Definition: point_types.hpp:177
pcl::PPFSignature::f3
float f3
Definition: point_types.hpp:1294
pcl::Narf36::descriptor
float descriptor[36]
Definition: point_types.hpp:1609
pcl::Intensity::operator<<
friend std::ostream & operator<<(std::ostream &os, const Intensity &p)
memory.h
Defines functions, macros and traits for allocating and using memory.
pcl::_PointSurfel::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1730
pcl::PointUV::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointUV &p)
pcl::PrincipalCurvatures::PrincipalCurvatures
PrincipalCurvatures(float _pc1, float _pc2)
Definition: point_types.hpp:1250
PCL_EXPORTS
#define PCL_EXPORTS
Definition: pcl_macros.h:323
pcl::Intensity32u::Intensity32u
Intensity32u(const _Intensity32u &p)
Definition: point_types.hpp:433
pcl::Narf36::Narf36
Narf36()=default
pcl::_ReferenceFrame
A structure representing the Local Reference Frame of a point.
Definition: point_types.hpp:1425
pcl::ESFSignature640::ESFSignature640
ESFSignature640()=default
pcl::_PointXYZL
Definition: point_types.hpp:485
pcl::PointWithScale::PointWithScale
PointWithScale(float _x, float _y, float _z, float _scale=1.f, float _angle=-1.f, float _response=0.f, int _octave=0)
Definition: point_types.hpp:1713
pcl::Vector4fMapConst
const Eigen::Map< const Eigen::Vector4f, Eigen::Aligned > Vector4fMapConst
Definition: point_types.hpp:183
pcl::VFHSignature308
A point structure representing the Viewpoint Feature Histogram (VFH).
Definition: point_types.hpp:1490
pcl::CPPFSignature::f2
float f2
Definition: point_types.hpp:1311
pcl::_PointXYZRGBNormal
Definition: point_types.hpp:912
pcl::CPPFSignature::CPPFSignature
CPPFSignature(float _f1, float _f2, float _f3, float _f4, float _f5, float _f6, float _f7, float _f8, float _f9, float _f10, float _alpha=0.f)
Definition: point_types.hpp:1317
pcl::IntensityGradient
A point structure representing the intensity gradient of an XYZI point cloud.
Definition: point_types.hpp:1644
pcl::PointSurfel::PointSurfel
PointSurfel(const _PointSurfel &p)
Definition: point_types.hpp:1753
pcl::SHOT352::SHOT352
SHOT352()=default
pcl::PFHRGBSignature250::histogram
float histogram[250]
Definition: point_types.hpp:1280