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