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