Point Cloud Library (PCL) 1.12.1
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
190namespace 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
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
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 */
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 {
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;
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 {
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;
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 {
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;
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 {
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 {
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;
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 */
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
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 */
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
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 {
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>
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. */
1778 /** \brief octave (pyramid layer) from which the keypoint has been extracted. */
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;
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 */
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;
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 {
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
1921POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_RGB,
1922 (std::uint32_t, rgba, rgba)
1923)
1924POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::RGB, pcl::_RGB)
1925
1926POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_Intensity,
1927 (float, intensity, intensity)
1928)
1929POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity, pcl::_Intensity)
1930
1931POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_Intensity8u,
1932 (std::uint8_t, intensity, intensity)
1933)
1934POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity8u, pcl::_Intensity8u)
1935
1936POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_Intensity32u,
1937 (std::uint32_t, intensity, intensity)
1938)
1939POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity32u, pcl::_Intensity32u)
1940
1941POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZ,
1942 (float, x, x)
1943 (float, y, y)
1944 (float, z, z)
1945)
1946POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZ, pcl::_PointXYZ)
1947
1948POINT_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)
1954POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBA, pcl::_PointXYZRGBA)
1955
1956POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZRGB,
1957 (float, x, x)
1958 (float, y, y)
1959 (float, z, z)
1960 (float, rgb, rgb)
1961)
1962POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGB, pcl::_PointXYZRGB)
1963
1964POINT_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)
1971POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBL, pcl::_PointXYZRGBL)
1972
1973POINT_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)
1981POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZLAB, pcl::_PointXYZLAB)
1982
1983POINT_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)
1991POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZHSV, pcl::_PointXYZHSV)
1992
1993POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointXY,
1994 (float, x, x)
1995 (float, y, y)
1996)
1997
1998POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointUV,
1999 (float, u, u)
2000 (float, v, v)
2001)
2002
2003POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::InterestPoint,
2004 (float, x, x)
2005 (float, y, y)
2006 (float, z, z)
2007 (float, strength, strength)
2008)
2009
2010POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZI,
2011 (float, x, x)
2012 (float, y, y)
2013 (float, z, z)
2014 (float, intensity, intensity)
2015)
2016POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZI, pcl::_PointXYZI)
2017
2018POINT_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
2025POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::Label,
2026 (std::uint32_t, label, label)
2027)
2028
2029POINT_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)
2035POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Normal, pcl::_Normal)
2036
2037POINT_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)
2042POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Axis, pcl::_Axis)
2043
2044POINT_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)
2053POINT_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)
2063POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBNormal, pcl::_PointXYZRGBNormal)
2064POINT_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)
2074POINT_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)
2084POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointWithRange,
2085 (float, x, x)
2086 (float, y, y)
2087 (float, z, z)
2088 (float, range, range)
2089)
2090
2091POINT_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)
2099POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointWithViewpoint, pcl::_PointWithViewpoint)
2100
2101POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::MomentInvariants,
2102 (float, j1, j1)
2103 (float, j2, j2)
2104 (float, j3, j3)
2105)
2106
2107POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PrincipalRadiiRSD,
2108 (float, r_min, r_min)
2109 (float, r_max, r_max)
2110)
2111
2112POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::Boundary,
2113 (std::uint8_t, boundary_point, boundary_point)
2114)
2115
2116POINT_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
2124POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PFHSignature125,
2125 (float[125], histogram, pfh)
2126)
2127
2128POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PFHRGBSignature250,
2129 (float[250], histogram, pfhrgb)
2130)
2131
2132POINT_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
2140POINT_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
2154POINT_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
2165POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::NormalBasedSignature12,
2166 (float[12], values, values)
2167)
2168
2169POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::ShapeContext1980,
2170 (float[1980], descriptor, shape_context)
2171 (float[9], rf, rf)
2172)
2173
2174POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::UniqueShapeContext1960,
2175 (float[1960], descriptor, shape_context)
2176 (float[9], rf, rf)
2177)
2178
2179POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::SHOT352,
2180 (float[352], descriptor, shot)
2181 (float[9], rf, rf)
2182)
2183
2184POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::SHOT1344,
2185 (float[1344], descriptor, shot)
2186 (float[9], rf, rf)
2187)
2188
2189POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::FPFHSignature33,
2190 (float[33], histogram, fpfh)
2191)
2192
2193POINT_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
2199POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::VFHSignature308,
2200 (float[308], histogram, vfh)
2201)
2202
2203POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::GRSDSignature21,
2204 (float[21], histogram, grsd)
2205)
2206
2207POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::ESFSignature640,
2208 (float[640], histogram, esf)
2209)
2210
2211POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::GASDSignature512,
2212 (float[512], histogram, gasd)
2213)
2214
2215POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::GASDSignature984,
2216 (float[984], histogram, gasd)
2217)
2218
2219POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::GASDSignature7992,
2220 (float[7992], histogram, gasd)
2221)
2222
2223POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::Narf36,
2224 (float[36], descriptor, descriptor)
2225)
2226
2227POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::GFPFHSignature16,
2228 (float[16], histogram, gfpfh)
2229)
2230
2231POINT_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
2237POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointWithScale,
2238 (float, x, x)
2239 (float, y, y)
2240 (float, z, z)
2241 (float, scale, scale)
2242)
2243
2244POINT_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
2257POINT_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)
2262POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::ReferenceFrame, pcl::_ReferenceFrame)
2263
2264POINT_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)
2272POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointDEM, pcl::_PointDEM)
2273
2274namespace 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>.
2279template<typename PointT>
2280struct 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};
2300template<typename PointT>
2301struct 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
2328namespace 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
Defines all the PCL implemented PointT point type structures.
#define PCL_MAKE_ALIGNED_OPERATOR_NEW
Macro to signal a class requires a custom allocator.
Definition: memory.h:63
std::bitset< 32 > BorderTraits
Data type to store extended information about a transition from foreground to backgroundSpecification...
Definition: point_types.h:307
Defines functions, macros and traits for allocating and using memory.
static constexpr int descriptorSize_v
Eigen::Map< Eigen::Vector4f, Eigen::Aligned > Vector4fMap
const Eigen::Map< const Vector4c, Eigen::Aligned > Vector4cMapConst
Eigen::Map< Vector4c, Eigen::Aligned > Vector4cMap
std::ostream & operator<<(std::ostream &os, const BivariatePolynomialT< real > &p)
const Eigen::Map< const Eigen::Vector3f > Vector3fMapConst
const Eigen::Map< const Vector3c > Vector3cMapConst
Eigen::Map< Eigen::Vector3f > Vector3fMap
Eigen::Matrix< std::uint8_t, 4, 1 > Vector4c
const Eigen::Map< const Eigen::Vector4f, Eigen::Aligned > Vector4fMapConst
const Eigen::Map< const Eigen::Array4f, Eigen::Aligned > Array4fMapConst
Eigen::Matrix< std::uint8_t, 3, 1 > Vector3c
Eigen::Map< Eigen::Array4f, Eigen::Aligned > Array4fMap
const Eigen::Map< const Eigen::Array3f > Array3fMapConst
Eigen::Map< Vector3c > Vector3cMap
Eigen::Map< Eigen::Array3f > Array3fMap
Defines all the PCL and non-PCL macros used.
#define PCL_EXPORTS
Definition: pcl_macros.h:323
#define PCL_IF_CONSTEXPR(x)
Definition: pcl_macros.h:449
float intensity_variance
float angle
Computed orientation of the keypoint (-1 if not applicable).
float response
The response by which the most strong keypoints have been selected.
int octave
octave (pyramid layer) from which the keypoint has been extracted.
float scale
Diameter of the meaningful keypoint neighborhood.
A point structure representing Euclidean xyz coordinates, and the intensity value.
std::uint32_t label
std::uint32_t label
A structure representing the Local Reference Frame of a point.
Eigen::Map< Eigen::Vector3f > getZAxisVector3fMap()
Eigen::Map< Eigen::Vector3f > getXAxisVector3fMap()
Eigen::Map< Eigen::Vector3f > getYAxisVector3fMap()
const Eigen::Map< const Eigen::Vector3f > getYAxisVector3fMap() const
Eigen::Map< Eigen::Matrix3f > getMatrix3fMap()
const Eigen::Map< const Eigen::Vector3f > getZAxisVector3fMap() const
const Eigen::Map< const Eigen::Vector3f > getXAxisVector3fMap() const
const Eigen::Map< const Eigen::Matrix3f > getMatrix3fMap() const
A point structure representing an Axis using its normal coordinates.
Axis(const _Axis &p)
Axis(float n_x, float n_y, float n_z)
A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK).
static constexpr int descriptorSize()
BRISKSignature512(float _scale, float _orientation)
friend std::ostream & operator<<(std::ostream &os, const BRISKSignature512 &p)
unsigned char descriptor[64]
A structure to store if a point in a range image lies on a border between an obstacle and the backgro...
friend std::ostream & operator<<(std::ostream &os, const BorderDescription &p)
A point structure representing a description of whether a point is lying on a surface boundary or not...
friend std::ostream & operator<<(std::ostream &os, const Boundary &p)
Boundary(std::uint8_t _boundary=0)
std::uint8_t boundary_point
A point structure for storing the Point Pair Feature (CPPF) values.
friend std::ostream & operator<<(std::ostream &os, const CPPFSignature &p)
CPPFSignature(float _alpha=0.f)
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)
A point structure representing the Ensemble of Shape Functions (ESF).
static constexpr int descriptorSize()
ESFSignature640()=default
friend std::ostream & operator<<(std::ostream &os, const ESFSignature640 &p)
A point structure representing the Fast Point Feature Histogram (FPFH).
FPFHSignature33()=default
static constexpr int descriptorSize()
friend std::ostream & operator<<(std::ostream &os, const FPFHSignature33 &p)
bool operator()(const PCLPointField &field)
Definition: PCLPointField.h:55
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor.
GASDSignature512()=default
static constexpr int descriptorSize()
friend std::ostream & operator<<(std::ostream &os, const GASDSignature512 &p)
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descr...
friend std::ostream & operator<<(std::ostream &os, const GASDSignature7992 &p)
static constexpr int descriptorSize()
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descr...
GASDSignature984()=default
friend std::ostream & operator<<(std::ostream &os, const GASDSignature984 &p)
static constexpr int descriptorSize()
A point structure representing the GFPFH descriptor with 16 bins.
friend std::ostream & operator<<(std::ostream &os, const GFPFHSignature16 &p)
GFPFHSignature16()=default
static constexpr int descriptorSize()
A point structure representing the Global Radius-based Surface Descriptor (GRSD).
static constexpr int descriptorSize()
GRSDSignature21()=default
friend std::ostream & operator<<(std::ostream &os, const GRSDSignature21 &p)
A point structure representing an N-D histogram.
float histogram[N]
static constexpr int descriptorSize()
A point structure representing the grayscale intensity in single-channel images.
Intensity32u(std::uint32_t _intensity=0)
Intensity32u(const _Intensity32u &p)
friend std::ostream & operator<<(std::ostream &os, const Intensity32u &p)
A point structure representing the grayscale intensity in single-channel images.
Intensity8u(const _Intensity8u &p)
Intensity8u(std::uint8_t _intensity=0)
friend std::ostream & operator<<(std::ostream &os, const Intensity8u &p)
A point structure representing the intensity gradient of an XYZI point cloud.
friend std::ostream & operator<<(std::ostream &os, const IntensityGradient &p)
IntensityGradient(float _x, float _y, float _z)
A point structure representing the grayscale intensity in single-channel images.
Intensity(float _intensity=0.f)
friend std::ostream & operator<<(std::ostream &os, const Intensity &p)
Intensity(const _Intensity &p)
A point structure representing an interest point with Euclidean xyz coordinates, and an interest valu...
friend std::ostream & operator<<(std::ostream &os, const Label &p)
Label(std::uint32_t _label=0)
std::uint32_t label
A point structure representing the three moment invariants.
MomentInvariants(float _j1, float _j2, float _j3)
friend std::ostream & operator<<(std::ostream &os, const MomentInvariants &p)
MomentInvariants()=default
A point structure representing the Narf descriptor.
Narf36()=default
Narf36(float _x, float _y, float _z)
float descriptor[36]
static constexpr int descriptorSize()
Narf36(float _x, float _y, float _z, float _roll, float _pitch, float _yaw)
friend std::ostream & operator<<(std::ostream &os, const Narf36 &p)
A point structure representing the Normal Based Signature for a feature matrix of 4-by-3.
friend std::ostream & operator<<(std::ostream &os, const NormalBasedSignature12 &p)
A point structure representing normal coordinates and the surface curvature estimate.
Normal(const _Normal &p)
Normal(float _curvature=0.f)
Normal(float n_x, float n_y, float n_z, float _curvature=0.f)
friend std::ostream & operator<<(std::ostream &os, const Normal &p)
std::string name
Definition: PCLPointField.h:14
std::uint8_t datatype
Definition: PCLPointField.h:17
A point structure representing the Point Feature Histogram with colors (PFHRGB).
friend std::ostream & operator<<(std::ostream &os, const PFHRGBSignature250 &p)
static constexpr int descriptorSize()
A point structure representing the Point Feature Histogram (PFH).
PFHSignature125()=default
static constexpr int descriptorSize()
friend std::ostream & operator<<(std::ostream &os, const PFHSignature125 &p)
A point structure for storing the Point Pair Color Feature (PPFRGB) values.
PPFRGBSignature(float _f1, float _f2, float _f3, float _f4, float _alpha, float _r, float _g, float _b)
PPFRGBSignature(float _f1, float _f2, float _f3, float _f4, float _alpha=0.f)
friend std::ostream & operator<<(std::ostream &os, const PPFRGBSignature &p)
PPFRGBSignature(float _alpha=0.f)
A point structure for storing the Point Pair Feature (PPF) values.
PPFSignature(float _f1, float _f2, float _f3, float _f4, float _alpha=0.f)
PPFSignature(float _alpha=0.f)
friend std::ostream & operator<<(std::ostream &os, const PPFSignature &p)
A point structure representing Digital Elevation Map.
PointDEM(const _PointDEM &p)
PointDEM(float _x, float _y, float _z, float _intensity, float _intensity_variance, float _height_variance)
PointDEM(float _x, float _y, float _z)
friend std::ostream & operator<<(std::ostream &os, const PointDEM &p)
A point structure representing Euclidean xyz coordinates, together with normal coordinates and the su...
PointNormal(float _x, float _y, float _z)
PointNormal(float _curvature=0.f)
friend std::ostream & operator<<(std::ostream &os, const PointNormal &p)
PointNormal(const _PointNormal &p)
PointNormal(float _x, float _y, float _z, float n_x, float n_y, float n_z, float _curvature=0.f)
A surfel, that is, a point structure representing Euclidean xyz coordinates, together with normal coo...
friend std::ostream & operator<<(std::ostream &os, const PointSurfel &p)
PointSurfel(const _PointSurfel &p)
A 2D point structure representing pixel image coordinates.
PointUV()=default
PointUV(float _u, float _v)
friend std::ostream & operator<<(std::ostream &os, const PointUV &p)
A point structure representing Euclidean xyz coordinates, padded with an extra range float.
PointWithRange(const _PointWithRange &p)
PointWithRange(float _x, float _y, float _z, float _range=0.f)
PointWithRange(float _range=0.f)
friend std::ostream & operator<<(std::ostream &os, const PointWithRange &p)
A point structure representing a 3-D position and scale.
friend std::ostream & operator<<(std::ostream &os, const PointWithScale &p)
PointWithScale(float _x, float _y, float _z, float _scale=1.f, float _angle=-1.f, float _response=0.f, int _octave=0)
PointWithScale(const _PointWithScale &p)
A point structure representing Euclidean xyz coordinates together with the viewpoint from which it wa...
PointWithViewpoint(float _x, float _y, float _z, float _vp_x, float _vp_y, float _vp_z)
PointWithViewpoint(float _x, float _y, float _z)
PointWithViewpoint(const _PointWithViewpoint &p)
A 2D point structure representing Euclidean xy coordinates.
friend std::ostream & operator<<(std::ostream &os, const PointXY &p)
PointXY(float _x, float _y)
PointXY()=default
PointXYZHSV(const _PointXYZHSV &p)
PointXYZHSV(float _x, float _y, float _z, float _h, float _s, float _v)
PointXYZHSV(float _h, float _s, float _v)
A point structure representing Euclidean xyz coordinates.
PointXYZ(const _PointXYZ &p)
PointXYZ(float _x, float _y, float _z)
PointXYZI(float _x, float _y, float _z, float _intensity=0.f)
PointXYZI(const _PointXYZI &p)
PointXYZI(float _intensity=0.f)
friend std::ostream & operator<<(std::ostream &os, const PointXYZI &p)
A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates...
PointXYZINormal(float _x, float _y, float _z, float _intensity=0.f)
friend std::ostream & operator<<(std::ostream &os, const PointXYZINormal &p)
PointXYZINormal(float _x, float _y, float _z, float _intensity, float n_x, float n_y, float n_z, float _curvature=0.f)
PointXYZINormal(const _PointXYZINormal &p)
PointXYZINormal(float _intensity=0.f)
A point structure representing Euclidean xyz coordinates, and the CIELAB color.
friend std::ostream & operator<<(std::ostream &os, const PointXYZLAB &p)
PointXYZLAB(const _PointXYZLAB &p)
PointXYZL(float _x, float _y, float _z, std::uint32_t _label=0)
PointXYZL(const _PointXYZL &p)
friend std::ostream & operator<<(std::ostream &os, const PointXYZL &p)
PointXYZL(std::uint32_t _label=0)
A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates a...
friend std::ostream & operator<<(std::ostream &os, const PointXYZLNormal &p)
PointXYZLNormal(float _x, float _y, float _z, std::uint32_t _label=0.f)
PointXYZLNormal(float _x, float _y, float _z, std::uint32_t _label, float n_x, float n_y, float n_z, float _curvature=0.f)
PointXYZLNormal(const _PointXYZLNormal &p)
PointXYZLNormal(std::uint32_t _label=0)
A point structure representing Euclidean xyz coordinates, and the RGBA color.
PointXYZRGBA(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
PointXYZRGBA(const _PointXYZRGBA &p)
PointXYZRGBA(float _x, float _y, float _z)
PointXYZRGBA(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
A point structure representing Euclidean xyz coordinates, and the RGB color.
PointXYZRGB(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
PointXYZRGB(const _PointXYZRGB &p)
PointXYZRGB(float _x, float _y, float _z)
PointXYZRGB(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
PointXYZRGBL(std::uint32_t _label=0)
PointXYZRGBL(const _PointXYZRGBL &p)
PointXYZRGBL(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint32_t _label=0)
PointXYZRGBL(float _x, float _y, float _z)
PointXYZRGBL(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coo...
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)
PointXYZRGBNormal(float _x, float _y, float _z)
PointXYZRGBNormal(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
PointXYZRGBNormal(float _curvature=0.f)
PointXYZRGBNormal(const _PointXYZRGBNormal &p)
PointXYZRGBNormal(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
friend std::ostream & operator<<(std::ostream &os, const PointXYZRGBNormal &p)
A point structure representing the principal curvatures and their magnitudes.
PrincipalCurvatures(float _x, float _y, float _z, float _pc1, float _pc2)
PrincipalCurvatures(float _pc1, float _pc2)
PrincipalCurvatures(float _x, float _y, float _z)
friend std::ostream & operator<<(std::ostream &os, const PrincipalCurvatures &p)
A point structure representing the minimum and maximum surface radii (in meters) computed using RSD.
friend std::ostream & operator<<(std::ostream &os, const PrincipalRadiiRSD &p)
PrincipalRadiiRSD(float _r_min, float _r_max)
A structure representing RGB color information.
friend std::ostream & operator<<(std::ostream &os, const RGB &p)
RGB(const _RGB &p)
RGB(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
ReferenceFrame(const _ReferenceFrame &p)
A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+col...
float descriptor[1344]
SHOT1344()=default
static constexpr int descriptorSize()
friend std::ostream & operator<<(std::ostream &os, const SHOT1344 &p)
A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape onl...
float descriptor[352]
SHOT352()=default
friend std::ostream & operator<<(std::ostream &os, const SHOT352 &p)
static constexpr int descriptorSize()
A point structure representing a Shape Context.
static constexpr int descriptorSize()
friend std::ostream & operator<<(std::ostream &os, const ShapeContext1980 &p)
ShapeContext1980()=default
A point structure representing a Unique Shape Context.
static constexpr int descriptorSize()
friend std::ostream & operator<<(std::ostream &os, const UniqueShapeContext1960 &p)
A point structure representing the Viewpoint Feature Histogram (VFH).
static constexpr int descriptorSize()
friend std::ostream & operator<<(std::ostream &os, const VFHSignature308 &p)
VFHSignature308()=default