Loading...
Searching...
No Matches
point_types.hpp
/*
* Software License Agreement (BSD License)
*
* Point Cloud Library (PCL) - www.pointclouds.org
* Copyright (c) 2010, Willow Garage, Inc.
* Copyright (c) 2012-, Open Perception, Inc.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the copyright holder(s) nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
#include <pcl/memory.h> // for PCL_MAKE_ALIGNED_OPERATOR_NEW
#include <pcl/pcl_config.h> // for PCL_XYZ_POINT_TYPES, PCL_NORMAL_POINT_TYPES
#include <pcl/pcl_macros.h> // for PCL_EXPORTS
#include <pcl/PCLPointField.h> // for PCLPointField
#include <pcl/point_types.h> // implementee
#include <pcl/register_point_struct.h> // for POINT_CLOUD_REGISTER_POINT_STRUCT, POINT_CLOUD_REGISTER_POINT_WRAPPER
#include <boost/mpl/and.hpp> // for boost::mpl::and_
#include <boost/mpl/bool.hpp> // for boost::mpl::bool_
#include <boost/mpl/contains.hpp> // for boost::mpl::contains
#include <boost/mpl/fold.hpp> // for boost::mpl::fold
#include <boost/mpl/or.hpp> // for boost::mpl::or_
#include <boost/mpl/placeholders.hpp> // for boost::mpl::_1, boost::mpl::_2
#include <boost/mpl/vector.hpp> // for boost::mpl::vector
#include <Eigen/Core> // for MatrixMap
#include <algorithm> // for copy_n, fill_n
#include <cstdint> // for uint8_t, uint32_t
#include <ostream> // for ostream, operator<<
#include <type_traits> // for enable_if_t
// Define all PCL point types
#define PCL_POINT_TYPES \
(pcl::PointXYZ) \
(pcl::PointXYZI) \
(pcl::PointXYZL) \
(pcl::Label) \
(pcl::PointXYZRGBA) \
(pcl::PointXYZRGB) \
(pcl::PointXYZRGBL) \
(pcl::PointXYZLAB) \
(pcl::PointXYZHSV) \
(pcl::PointXY) \
(pcl::InterestPoint) \
(pcl::Axis) \
(pcl::Normal) \
(pcl::PointNormal) \
(pcl::PointXYZRGBNormal) \
(pcl::PointXYZINormal) \
(pcl::PointXYZLNormal) \
(pcl::PointWithRange) \
(pcl::PointWithViewpoint) \
(pcl::MomentInvariants) \
(pcl::PrincipalRadiiRSD) \
(pcl::Boundary) \
(pcl::PrincipalCurvatures) \
(pcl::PFHSignature125) \
(pcl::PFHRGBSignature250) \
(pcl::PPFSignature) \
(pcl::CPPFSignature) \
(pcl::PPFRGBSignature) \
(pcl::NormalBasedSignature12) \
(pcl::FPFHSignature33) \
(pcl::VFHSignature308) \
(pcl::GASDSignature512) \
(pcl::GASDSignature984) \
(pcl::GASDSignature7992) \
(pcl::GRSDSignature21) \
(pcl::ESFSignature640) \
(pcl::BRISKSignature512) \
(pcl::Narf36) \
(pcl::IntensityGradient) \
(pcl::PointWithScale) \
(pcl::PointSurfel) \
(pcl::ShapeContext1980) \
(pcl::UniqueShapeContext1960) \
(pcl::SHOT352) \
(pcl::SHOT1344) \
(pcl::PointUV) \
(pcl::ReferenceFrame) \
(pcl::PointDEM)
// Define all point types that include RGB data
#define PCL_RGB_POINT_TYPES \
(pcl::PointXYZRGBA) \
(pcl::PointXYZRGB) \
(pcl::PointXYZRGBL) \
(pcl::PointXYZRGBNormal) \
(pcl::PointSurfel) \
// Define all point types with XYZ and label
#define PCL_XYZL_POINT_TYPES \
(pcl::PointXYZL) \
(pcl::PointXYZRGBL) \
(pcl::PointXYZLNormal)
// Define all point types that represent features
#define PCL_FEATURE_POINT_TYPES \
(pcl::PFHSignature125) \
(pcl::PFHRGBSignature250) \
(pcl::PPFSignature) \
(pcl::CPPFSignature) \
(pcl::PPFRGBSignature) \
(pcl::NormalBasedSignature12) \
(pcl::FPFHSignature33) \
(pcl::VFHSignature308) \
(pcl::GASDSignature512) \
(pcl::GASDSignature984) \
(pcl::GASDSignature7992) \
(pcl::GRSDSignature21) \
(pcl::ESFSignature640) \
(pcl::BRISKSignature512) \
(pcl::Narf36)
// Define all point types that have descriptorSize() member function
#define PCL_DESCRIPTOR_FEATURE_POINT_TYPES \
(pcl::PFHSignature125) \
(pcl::PFHRGBSignature250) \
(pcl::FPFHSignature33) \
(pcl::VFHSignature308) \
(pcl::GASDSignature512) \
(pcl::GASDSignature984) \
(pcl::GASDSignature7992) \
(pcl::GRSDSignature21) \
(pcl::ESFSignature640) \
(pcl::BRISKSignature512) \
(pcl::Narf36)
namespace pcl
{
namespace detail
{
namespace traits
{
template<typename FeaturePointT> struct descriptorSize {};
template<> struct descriptorSize<PFHSignature125> { static constexpr const int value = 125; };
template<> struct descriptorSize<PFHRGBSignature250> { static constexpr const int value = 250; };
template<> struct descriptorSize<ShapeContext1980> { static constexpr const int value = 1980; };
template<> struct descriptorSize<UniqueShapeContext1960> { static constexpr const int value = 1960; };
template<> struct descriptorSize<SHOT352> { static constexpr const int value = 352; };
template<> struct descriptorSize<SHOT1344> { static constexpr const int value = 1344; };
template<> struct descriptorSize<FPFHSignature33> { static constexpr const int value = 33; };
template<> struct descriptorSize<VFHSignature308> { static constexpr const int value = 308; };
template<> struct descriptorSize<GRSDSignature21> { static constexpr const int value = 21; };
template<> struct descriptorSize<BRISKSignature512> { static constexpr const int value = 512; };
template<> struct descriptorSize<ESFSignature640> { static constexpr const int value = 640; };
template<> struct descriptorSize<GASDSignature512> { static constexpr const int value = 512; };
template<> struct descriptorSize<GASDSignature984> { static constexpr const int value = 984; };
template<> struct descriptorSize<GASDSignature7992> { static constexpr const int value = 7992; };
template<> struct descriptorSize<GFPFHSignature16> { static constexpr const int value = 16; };
template<> struct descriptorSize<Narf36> { static constexpr const int value = 36; };
template<int N> struct descriptorSize<Histogram<N>> { static constexpr const int value = N; };
template<typename FeaturePointT>
static constexpr int descriptorSize_v = descriptorSize<FeaturePointT>::value;
}
}
using Vector2fMap = Eigen::Map<Eigen::Vector2f>;
using Vector2fMapConst = const Eigen::Map<const Eigen::Vector2f>;
using Array3fMap = Eigen::Map<Eigen::Array3f>;
using Array3fMapConst = const Eigen::Map<const Eigen::Array3f>;
using Array4fMap = Eigen::Map<Eigen::Array4f, Eigen::Aligned>;
using Array4fMapConst = const Eigen::Map<const Eigen::Array4f, Eigen::Aligned>;
using Vector3fMap = Eigen::Map<Eigen::Vector3f>;
using Vector3fMapConst = const Eigen::Map<const Eigen::Vector3f>;
using Vector4fMap = Eigen::Map<Eigen::Vector4f, Eigen::Aligned>;
using Vector4fMapConst = const Eigen::Map<const Eigen::Vector4f, Eigen::Aligned>;
using Vector3c = Eigen::Matrix<std::uint8_t, 3, 1>;
using Vector3cMap = Eigen::Map<Vector3c>;
using Vector3cMapConst = const Eigen::Map<const Vector3c>;
using Vector4c = Eigen::Matrix<std::uint8_t, 4, 1>;
using Vector4cMap = Eigen::Map<Vector4c, Eigen::Aligned>;
using Vector4cMapConst = const Eigen::Map<const Vector4c, Eigen::Aligned>;
#define PCL_ADD_UNION_POINT4D \
union EIGEN_ALIGN16 { \
float data[4]; \
struct { \
float x; \
float y; \
float z; \
}; \
};
#define PCL_ADD_EIGEN_MAPS_POINT4D \
inline pcl::Vector2fMap getVector2fMap () { return (pcl::Vector2fMap (data)); } \
inline pcl::Vector2fMapConst getVector2fMap () const { return (pcl::Vector2fMapConst (data)); } \
inline pcl::Vector3fMap getVector3fMap () { return (pcl::Vector3fMap (data)); } \
inline pcl::Vector3fMapConst getVector3fMap () const { return (pcl::Vector3fMapConst (data)); } \
inline pcl::Vector4fMap getVector4fMap () { return (pcl::Vector4fMap (data)); } \
inline pcl::Vector4fMapConst getVector4fMap () const { return (pcl::Vector4fMapConst (data)); } \
inline pcl::Array3fMap getArray3fMap () { return (pcl::Array3fMap (data)); } \
inline pcl::Array3fMapConst getArray3fMap () const { return (pcl::Array3fMapConst (data)); } \
inline pcl::Array4fMap getArray4fMap () { return (pcl::Array4fMap (data)); } \
inline pcl::Array4fMapConst getArray4fMap () const { return (pcl::Array4fMapConst (data)); }
#define PCL_ADD_POINT4D \
PCL_ADD_UNION_POINT4D \
PCL_ADD_EIGEN_MAPS_POINT4D
#define PCL_ADD_UNION_NORMAL4D \
union EIGEN_ALIGN16 { \
float data_n[4]; \
float normal[3]; \
struct { \
float normal_x; \
float normal_y; \
float normal_z; \
}; \
};
#define PCL_ADD_EIGEN_MAPS_NORMAL4D \
inline pcl::Vector3fMap getNormalVector3fMap () { return (pcl::Vector3fMap (data_n)); } \
inline pcl::Vector3fMapConst getNormalVector3fMap () const { return (pcl::Vector3fMapConst (data_n)); } \
inline pcl::Vector4fMap getNormalVector4fMap () { return (pcl::Vector4fMap (data_n)); } \
inline pcl::Vector4fMapConst getNormalVector4fMap () const { return (pcl::Vector4fMapConst (data_n)); }
#define PCL_ADD_NORMAL4D \
PCL_ADD_UNION_NORMAL4D \
PCL_ADD_EIGEN_MAPS_NORMAL4D
#define PCL_ADD_UNION_RGB \
union \
{ \
union \
{ \
struct \
{ \
std::uint8_t b; \
std::uint8_t g; \
std::uint8_t r; \
std::uint8_t a; \
}; \
float rgb; \
}; \
std::uint32_t rgba; \
};
#define PCL_ADD_EIGEN_MAPS_RGB \
inline Eigen::Vector3i getRGBVector3i () { return (Eigen::Vector3i (r, g, b)); } \
inline const Eigen::Vector3i getRGBVector3i () const { return (Eigen::Vector3i (r, g, b)); } \
inline Eigen::Vector4i getRGBVector4i () { return (Eigen::Vector4i (r, g, b, a)); } \
inline const Eigen::Vector4i getRGBVector4i () const { return (Eigen::Vector4i (r, g, b, a)); } \
inline Eigen::Vector4i getRGBAVector4i () { return (Eigen::Vector4i (r, g, b, a)); } \
inline const Eigen::Vector4i getRGBAVector4i () const { return (Eigen::Vector4i (r, g, b, a)); } \
inline pcl::Vector3cMap getBGRVector3cMap () { return (pcl::Vector3cMap (reinterpret_cast<std::uint8_t*> (&rgba))); } \
inline pcl::Vector3cMapConst getBGRVector3cMap () const { return (pcl::Vector3cMapConst (reinterpret_cast<const std::uint8_t*> (&rgba))); } \
inline pcl::Vector4cMap getBGRAVector4cMap () { return (pcl::Vector4cMap (reinterpret_cast<std::uint8_t*> (&rgba))); } \
inline pcl::Vector4cMapConst getBGRAVector4cMap () const { return (pcl::Vector4cMapConst (reinterpret_cast<const std::uint8_t*> (&rgba))); }
#define PCL_ADD_RGB \
PCL_ADD_UNION_RGB \
PCL_ADD_EIGEN_MAPS_RGB
#define PCL_ADD_INTENSITY \
struct \
{ \
float intensity; \
}; \
#define PCL_ADD_INTENSITY_8U \
struct \
{ \
std::uint8_t intensity; \
}; \
#define PCL_ADD_INTENSITY_32U \
struct \
{ \
std::uint32_t intensity; \
}; \
struct _PointXYZ
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZ& p);
/** \brief A point structure representing Euclidean xyz coordinates. (SSE friendly)
* \ingroup common
*/
struct EIGEN_ALIGN16 PointXYZ : public _PointXYZ
{
inline constexpr PointXYZ (const _PointXYZ &p): PointXYZ(p.x, p.y, p.z) {}
inline constexpr PointXYZ (): PointXYZ(0.f, 0.f, 0.f) {}
inline constexpr PointXYZ (float _x, float _y, float _z) : _PointXYZ{{{_x, _y, _z, 1.f}}} {}
friend std::ostream& operator << (std::ostream& os, const PointXYZ& p);
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
#ifdef RGB
#undef RGB
#endif
struct _RGB
{
PCL_ADD_RGB
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const RGB& p);
/** \brief A structure representing RGB color information.
*
* The RGBA information is available either as separate r, g, b, or as a
* packed std::uint32_t rgba value. To pack it, use:
*
* \code
* int rgb = ((int)r) << 16 | ((int)g) << 8 | ((int)b);
* \endcode
*
* To unpack it use:
*
* \code
* int rgb = ...;
* std::uint8_t r = (rgb >> 16) & 0x0000ff;
* std::uint8_t g = (rgb >> 8) & 0x0000ff;
* std::uint8_t b = (rgb) & 0x0000ff;
* \endcode
*
*/
struct RGB: public _RGB
{
inline constexpr RGB (const _RGB &p) : RGB{p.r, p.g, p.b, p.a} {}
inline constexpr RGB (): RGB(0, 0, 0) {}
inline constexpr RGB (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a = 255) : _RGB{{{{_b, _g, _r, _a}}}} {}
friend std::ostream& operator << (std::ostream& os, const RGB& p);
};
struct _Intensity
{
PCL_ADD_INTENSITY
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Intensity& p);
/** \brief A point structure representing the grayscale intensity in single-channel images.
* Intensity is represented as a float value.
* \ingroup common
*/
struct Intensity: public _Intensity
{
inline constexpr Intensity (const _Intensity &p) : Intensity{p.intensity} {}
inline constexpr Intensity (float _intensity = 0.f) : _Intensity{_intensity} {}
friend std::ostream& operator << (std::ostream& os, const Intensity& p);
};
struct _Intensity8u
{
PCL_ADD_INTENSITY_8U;
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Intensity8u& p);
/** \brief A point structure representing the grayscale intensity in single-channel images.
* Intensity is represented as a std::uint8_t value.
* \ingroup common
*/
struct Intensity8u: public _Intensity8u
{
inline constexpr Intensity8u (const _Intensity8u &p) : Intensity8u{p.intensity} {}
inline constexpr Intensity8u (std::uint8_t _intensity = 0) : _Intensity8u{_intensity} {}
#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 1101
inline constexpr operator unsigned char() const
{
return intensity;
}
#endif
friend std::ostream& operator << (std::ostream& os, const Intensity8u& p);
};
struct _Intensity32u
{
PCL_ADD_INTENSITY_32U;
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Intensity32u& p);
/** \brief A point structure representing the grayscale intensity in single-channel images.
* Intensity is represented as a std::uint32_t value.
* \ingroup common
*/
struct Intensity32u: public _Intensity32u
{
inline constexpr Intensity32u (const _Intensity32u &p) : Intensity32u{p.intensity} {}
inline constexpr Intensity32u (std::uint32_t _intensity = 0) : _Intensity32u{_intensity} {}
friend std::ostream& operator << (std::ostream& os, const Intensity32u& p);
};
/** \brief A point structure representing Euclidean xyz coordinates, and the intensity value.
* \ingroup common
*/
struct EIGEN_ALIGN16 _PointXYZI
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
union
{
struct
{
float intensity;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZI& p);
struct PointXYZI : public _PointXYZI
{
inline constexpr PointXYZI (const _PointXYZI &p) : PointXYZI{p.x, p.y, p.z, p.intensity} {}
inline constexpr PointXYZI (float _intensity = 0.f) : PointXYZI(0.f, 0.f, 0.f, _intensity) {}
inline constexpr PointXYZI (float _x, float _y, float _z, float _intensity = 0.f) : _PointXYZI{{{_x, _y, _z, 1.0f}}, {{_intensity}}} {}
friend std::ostream& operator << (std::ostream& os, const PointXYZI& p);
};
struct EIGEN_ALIGN16 _PointXYZL
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
std::uint32_t label;
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZL& p);
struct PointXYZL : public _PointXYZL
{
inline constexpr PointXYZL (const _PointXYZL &p) : PointXYZL{p.x, p.y, p.z, p.label} {}
inline constexpr PointXYZL (std::uint32_t _label = 0) : PointXYZL(0.f, 0.f, 0.f, _label) {}
inline constexpr PointXYZL (float _x, float _y, float _z, std::uint32_t _label = 0) : _PointXYZL{{{_x, _y, _z, 1.0f}}, _label} {}
friend std::ostream& operator << (std::ostream& os, const PointXYZL& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Label& p);
struct Label
{
std::uint32_t label = 0;
inline constexpr Label (std::uint32_t _label = 0): label(_label) {}
friend std::ostream& operator << (std::ostream& os, const Label& p);
};
struct EIGEN_ALIGN16 _PointXYZRGBA
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_ADD_RGB
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZRGBA& p);
/** \brief A point structure representing Euclidean xyz coordinates, and the RGBA color.
*
* The RGBA information is available either as separate r, g, b, or as a
* packed std::uint32_t rgba value. To pack it, use:
*
* \code
* int rgb = ((int)r) << 16 | ((int)g) << 8 | ((int)b);
* \endcode
*
* To unpack it use:
*
* \code
* int rgb = ...;
* std::uint8_t r = (rgb >> 16) & 0x0000ff;
* std::uint8_t g = (rgb >> 8) & 0x0000ff;
* std::uint8_t b = (rgb) & 0x0000ff;
* \endcode
*
* \ingroup common
*/
struct EIGEN_ALIGN16 PointXYZRGBA : public _PointXYZRGBA
{
inline constexpr PointXYZRGBA (const _PointXYZRGBA &p) : PointXYZRGBA{p.x, p.y, p.z, p.r, p.g, p.b, p.a} {}
inline constexpr PointXYZRGBA (): PointXYZRGBA (0, 0, 0, 255) {}
inline constexpr PointXYZRGBA (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a):
PointXYZRGBA (0.f, 0.f, 0.f, _r, _g, _b, _a) {}
inline constexpr PointXYZRGBA (float _x, float _y, float _z):
PointXYZRGBA (_x, _y, _z, 0, 0, 0, 255) {}
inline constexpr PointXYZRGBA (float _x, float _y, float _z, std::uint8_t _r,
std::uint8_t _g, std::uint8_t _b, std::uint8_t _a) : _PointXYZRGBA{{{_x, _y, _z, 1.0f}}, {{{_b, _g, _r, _a}}}} {}
friend std::ostream& operator << (std::ostream& os, const PointXYZRGBA& p);
};
struct EIGEN_ALIGN16 _PointXYZRGB
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_ADD_RGB
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
struct EIGEN_ALIGN16 _PointXYZRGBL
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_ADD_RGB
std::uint32_t label;
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZRGB& p);
/** \brief A point structure representing Euclidean xyz coordinates, and the RGB color.
*
* Due to historical reasons (PCL was first developed as a ROS package), the
* RGB information is packed into an integer and casted to a float. This is
* something we wish to remove in the near future, but in the meantime, the
* following code snippet should help you pack and unpack RGB colors in your
* PointXYZRGB structure:
*
* \code
* // pack r/g/b into rgb
* std::uint8_t r = 255, g = 0, b = 0; // Example: Red color
* std::uint32_t rgb = ((std::uint32_t)r << 16 | (std::uint32_t)g << 8 | (std::uint32_t)b);
* p.rgb = *reinterpret_cast<float*>(&rgb);
* \endcode
*
* To unpack the data into separate values, use:
*
* \code
* PointXYZRGB p;
* // unpack rgb into r/g/b
* std::uint32_t rgb = *reinterpret_cast<int*>(&p.rgb);
* std::uint8_t r = (rgb >> 16) & 0x0000ff;
* std::uint8_t g = (rgb >> 8) & 0x0000ff;
* std::uint8_t b = (rgb) & 0x0000ff;
* \endcode
*
*
* Alternatively, from 1.1.0 onwards, you can use p.r, p.g, and p.b directly.
*
* \ingroup common
*/
struct EIGEN_ALIGN16 PointXYZRGB : public _PointXYZRGB
{
inline constexpr PointXYZRGB (const _PointXYZRGB &p) : PointXYZRGB{p.x, p.y, p.z, p.r, p.g, p.b} {}
inline constexpr PointXYZRGB (): PointXYZRGB (0.f, 0.f, 0.f) {}
inline constexpr PointXYZRGB (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
PointXYZRGB (0.f, 0.f, 0.f, _r, _g, _b) {}
inline constexpr PointXYZRGB (float _x, float _y, float _z):
PointXYZRGB (_x, _y, _z, 0, 0, 0) {}
inline constexpr PointXYZRGB (float _x, float _y, float _z,
std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
_PointXYZRGB{{{_x, _y, _z, 1.0f}}, {{{_b, _g, _r, 255}}}} {}
friend std::ostream& operator << (std::ostream& os, const PointXYZRGB& p);
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZRGBL& p);
struct EIGEN_ALIGN16 PointXYZRGBL : public _PointXYZRGBL
{
inline constexpr PointXYZRGBL (const _PointXYZRGBL &p) : PointXYZRGBL{p.x, p.y, p.z, p.r, p.g, p.b, p.label, p.a} {}
inline constexpr PointXYZRGBL (std::uint32_t _label = 0):
PointXYZRGBL (0.f, 0.f, 0.f, 0, 0, 0, _label) {}
inline constexpr PointXYZRGBL (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
PointXYZRGBL (0.f, 0.f, 0.f, _r, _g, _b) {}
inline constexpr PointXYZRGBL (float _x, float _y, float _z):
PointXYZRGBL (_x, _y, _z, 0, 0, 0) {}
inline constexpr PointXYZRGBL (float _x, float _y, float _z,
std::uint8_t _r, std::uint8_t _g, std::uint8_t _b,
std::uint32_t _label = 0, std::uint8_t _a = 255) :
_PointXYZRGBL{{{_x, _y, _z, 1.0f}}, {{{_b, _g, _r, _a}}}, _label} {}
friend std::ostream& operator << (std::ostream& os, const PointXYZRGBL& p);
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
struct EIGEN_ALIGN16 _PointXYZLAB
{
PCL_ADD_POINT4D // this adds the members x,y,z
union
{
struct
{
float L;
float a;
float b;
};
float data_lab[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZLAB& p);
/** \brief A point structure representing Euclidean xyz coordinates, and the CIELAB color.
* \ingroup common
*/
struct PointXYZLAB : public _PointXYZLAB
{
inline constexpr PointXYZLAB (const _PointXYZLAB &p) : PointXYZLAB{p.x, p.y, p.z, p.L, p.a, p.b} {}
inline constexpr PointXYZLAB() : PointXYZLAB{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f} {}
inline constexpr PointXYZLAB (float _x, float _y, float _z,
float _l, float _a, float _b) :
_PointXYZLAB{ {{_x, _y, _z, 1.0f}}, {{_l, _a, _b}} } {}
friend std::ostream& operator << (std::ostream& os, const PointXYZLAB& p);
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
struct EIGEN_ALIGN16 _PointXYZHSV
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
union
{
struct
{
float h;
float s;
float v;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZHSV& p);
struct EIGEN_ALIGN16 PointXYZHSV : public _PointXYZHSV
{
inline constexpr PointXYZHSV (const _PointXYZHSV &p) :
PointXYZHSV{p.x, p.y, p.z, p.h, p.s, p.v} {}
inline constexpr PointXYZHSV (): PointXYZHSV (0.f, 0.f, 0.f) {}
// @TODO: Use strong types??
// This is a dangerous type, doesn't behave like others
inline constexpr PointXYZHSV (float _h, float _s, float _v):
PointXYZHSV (0.f, 0.f, 0.f, _h, _s, _v) {}
inline constexpr PointXYZHSV (float _x, float _y, float _z,
float _h, float _s, float _v) :
_PointXYZHSV{{{_x, _y, _z, 1.0f}}, {{_h, _s, _v}}} {}
friend std::ostream& operator << (std::ostream& os, const PointXYZHSV& p);
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXY& p);
/** \brief A 2D point structure representing Euclidean xy coordinates.
* \ingroup common
*/
// NOLINTBEGIN(modernize-use-default-member-init)
struct PointXY
{
union
{
float data[2];
struct
{
float x;
float y;
};
};
inline constexpr PointXY(float _x, float _y): x(_x), y(_y) {}
inline constexpr PointXY(): x(0.0f), y(0.0f) {}
inline pcl::Vector2fMap getVector2fMap () { return (pcl::Vector2fMap (data)); }
inline pcl::Vector2fMapConst getVector2fMap () const { return (pcl::Vector2fMapConst (data)); }
friend std::ostream& operator << (std::ostream& os, const PointXY& p);
};
// NOLINTEND(modernize-use-default-member-init)
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointUV& p);
/** \brief A 2D point structure representing pixel image coordinates.
* \note We use float to be able to represent subpixels.
* \ingroup common
*/
struct PointUV
{
float u = 0.f;
float v = 0.f;
inline constexpr PointUV() = default;
inline constexpr PointUV(float _u, float _v): u(_u), v(_v) {}
friend std::ostream& operator << (std::ostream& os, const PointUV& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const InterestPoint& p);
/** \brief A point structure representing an interest point with Euclidean xyz coordinates, and an interest value.
* \ingroup common
*/
// @TODO: inheritance trick like on other PointTypes
struct EIGEN_ALIGN16 InterestPoint
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
union
{
struct
{
float strength;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
friend std::ostream& operator << (std::ostream& os, const InterestPoint& p);
};
struct EIGEN_ALIGN16 _Normal
{
PCL_ADD_NORMAL4D // This adds the member normal[3] which can also be accessed using the point (which is float[4])
union
{
struct
{
float curvature;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Normal& p);
/** \brief A point structure representing normal coordinates and the surface curvature estimate. (SSE friendly)
* \ingroup common
*/
struct Normal : public _Normal
{
inline constexpr Normal (const _Normal &p) : Normal {p.normal_x, p.normal_y, p.normal_z, p.curvature} {}
inline constexpr Normal (float _curvature = 0.f): Normal (0.f, 0.f, 0.f, _curvature) {}
inline constexpr Normal (float n_x, float n_y, float n_z, float _curvature = 0.f) :
_Normal{{{n_x, n_y, n_z, 0.0f}}, {{_curvature}}} {}
friend std::ostream& operator << (std::ostream& os, const Normal& p);
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
struct EIGEN_ALIGN16 _Axis
{
PCL_ADD_NORMAL4D
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Axis& p);
/** \brief A point structure representing an Axis using its normal coordinates. (SSE friendly)
* \ingroup common
*/
struct EIGEN_ALIGN16 Axis : public _Axis
{
inline constexpr Axis (const _Axis &p) : Axis{p.normal_x, p.normal_y, p.normal_z} {}
inline constexpr Axis (): Axis (0.f, 0.f, 0.f) {}
inline constexpr Axis (float n_x, float n_y, float n_z) : _Axis{{{n_x, n_y, n_z, 0.0f}}} {}
friend std::ostream& operator << (std::ostream& os, const Axis& p);
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
struct EIGEN_ALIGN16 _PointNormal
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_ADD_NORMAL4D // This adds the member normal[3] which can also be accessed using the point (which is float[4])
union
{
struct
{
float curvature;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointNormal& p);
/** \brief A point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate. (SSE friendly)
* \ingroup common
*/
struct PointNormal : public _PointNormal
{
inline constexpr PointNormal (const _PointNormal &p) : PointNormal{p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature} {}
inline constexpr PointNormal (float _curvature = 0.f): PointNormal (0.f, 0.f, 0.f, 0.f, 0.f, 0.f, _curvature) {}
inline constexpr PointNormal (float _x, float _y, float _z):
PointNormal (_x, _y, _z, 0.f, 0.f, 0.f, 0.f) {}
inline constexpr PointNormal (float _x, float _y, float _z, float n_x, float n_y, float n_z, float _curvature = 0.f) :
_PointNormal{{{_x, _y, _z, 1.0f}}, {{n_x, n_y, n_z, 0.0f}}, {{_curvature}}} {}
friend std::ostream& operator << (std::ostream& os, const PointNormal& p);
};
struct EIGEN_ALIGN16 _PointXYZRGBNormal
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_ADD_NORMAL4D // This adds the member normal[3] which can also be accessed using the point (which is float[4])
union
{
struct
{
PCL_ADD_UNION_RGB
float curvature;
};
float data_c[4];
};
PCL_ADD_EIGEN_MAPS_RGB
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZRGBNormal& p);
/** \brief A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate.
* Due to historical reasons (PCL was first developed as a ROS package), the
* RGB information is packed into an integer and casted to a float. This is
* something we wish to remove in the near future, but in the meantime, the
* following code snippet should help you pack and unpack RGB colors in your
* PointXYZRGB structure:
*
* \code
* // pack r/g/b into rgb
* std::uint8_t r = 255, g = 0, b = 0; // Example: Red color
* std::uint32_t rgb = ((std::uint32_t)r << 16 | (std::uint32_t)g << 8 | (std::uint32_t)b);
* p.rgb = *reinterpret_cast<float*>(&rgb);
* \endcode
*
* To unpack the data into separate values, use:
*
* \code
* PointXYZRGB p;
* // unpack rgb into r/g/b
* std::uint32_t rgb = *reinterpret_cast<int*>(&p.rgb);
* std::uint8_t r = (rgb >> 16) & 0x0000ff;
* std::uint8_t g = (rgb >> 8) & 0x0000ff;
* std::uint8_t b = (rgb) & 0x0000ff;
* \endcode
*
*
* Alternatively, from 1.1.0 onwards, you can use p.r, p.g, and p.b directly.
* \ingroup common
*/
struct PointXYZRGBNormal : public _PointXYZRGBNormal
{
inline constexpr PointXYZRGBNormal (const _PointXYZRGBNormal &p) :
PointXYZRGBNormal {p.x, p.y, p.z, p.r, p.g, p.b, p.a, p.normal_x, p.normal_y, p.normal_z, p.curvature} {}
inline constexpr PointXYZRGBNormal (float _curvature = 0.f):
PointXYZRGBNormal (0.f, 0.f, 0.f, 0, 0, 0, 0.f, 0.f, 0.f, _curvature) {}
inline constexpr PointXYZRGBNormal (float _x, float _y, float _z):
PointXYZRGBNormal (_x, _y, _z, 0, 0, 0) {}
inline constexpr PointXYZRGBNormal (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
PointXYZRGBNormal (0.f, 0.f, 0.f, _r, _g, _b) {}
inline constexpr PointXYZRGBNormal (float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
PointXYZRGBNormal (_x, _y, _z, _r, _g, _b, 0.f, 0.f, 0.f) {}
inline constexpr 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{
{{_x, _y, _z, 1.0f}},
{{n_x, n_y, n_z, 0.0f}},
{{ {{{_b, _g, _r, 255u}}}, _curvature }}
}
{}
inline constexpr PointXYZRGBNormal (float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b,
std::uint8_t _a, float n_x, float n_y, float n_z, float _curvature = 0.f) :
_PointXYZRGBNormal{
{{_x, _y, _z, 1.0f}},
{{n_x, n_y, n_z, 0.0f}},
{{ {{{_b, _g, _r, _a}}}, _curvature }}
}
{}
friend std::ostream& operator << (std::ostream& os, const PointXYZRGBNormal& p);
};
struct EIGEN_ALIGN16 _PointXYZINormal
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_ADD_NORMAL4D // This adds the member normal[3] which can also be accessed using the point (which is float[4])
union
{
struct
{
float intensity;
float curvature;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZINormal& p);
/** \brief A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate.
* \ingroup common
*/
struct PointXYZINormal : public _PointXYZINormal
{
inline constexpr PointXYZINormal (const _PointXYZINormal &p) :
PointXYZINormal {p.x, p.y, p.z, p.intensity, p.normal_x, p.normal_y, p.normal_z, p.curvature} {}
inline constexpr PointXYZINormal (float _intensity = 0.f): PointXYZINormal (0.f, 0.f, 0.f, _intensity) {}
inline constexpr PointXYZINormal (float _x, float _y, float _z, float _intensity = 0.f):
PointXYZINormal (_x, _y, _z, _intensity, 0.f, 0.f, 0.f) {}
inline constexpr PointXYZINormal (float _x, float _y, float _z, float _intensity,
float n_x, float n_y, float n_z, float _curvature = 0.f) :
_PointXYZINormal{
{{_x, _y, _z, 1.0f}},
{{n_x, n_y, n_z, 0.0f}},
{{_intensity, _curvature}}
}
{}
friend std::ostream& operator << (std::ostream& os, const PointXYZINormal& p);
};
//----
struct EIGEN_ALIGN16 _PointXYZLNormal
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_ADD_NORMAL4D // This adds the member normal[3] which can also be accessed using the point (which is float[4])
union
{
struct
{
std::uint32_t label;
float curvature;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointXYZLNormal& p);
/** \brief A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates and the surface curvature estimate.
* \ingroup common
*/
struct PointXYZLNormal : public _PointXYZLNormal
{
inline constexpr PointXYZLNormal (const _PointXYZLNormal &p) :
PointXYZLNormal {p.x, p.y, p.z, p.label, p.normal_x, p.normal_y, p.normal_z, p.curvature} {}
inline constexpr PointXYZLNormal (std::uint32_t _label = 0u): PointXYZLNormal (0.f, 0.f, 0.f, _label) {}
inline constexpr PointXYZLNormal (float _x, float _y, float _z, std::uint32_t _label = 0u) :
PointXYZLNormal (_x, _y, _z, _label, 0.f, 0.f, 0.f) {}
inline constexpr 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{
{{_x, _y, _z, 1.0f}},
{{n_x, n_y, n_z, 0.0f}},
{{_label, _curvature}}
}
{}
friend std::ostream& operator << (std::ostream& os, const PointXYZLNormal& p);
};
// ---
struct EIGEN_ALIGN16 _PointWithRange
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
union
{
struct
{
float range;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointWithRange& p);
/** \brief A point structure representing Euclidean xyz coordinates, padded with an extra range float.
* \ingroup common
*/
struct PointWithRange : public _PointWithRange
{
inline constexpr PointWithRange (const _PointWithRange &p) : PointWithRange{p.x, p.y, p.z, p.range} {}
inline constexpr PointWithRange (float _range = 0.f): PointWithRange (0.f, 0.f, 0.f, _range) {}
inline constexpr PointWithRange (float _x, float _y, float _z, float _range = 0.f) :
_PointWithRange{{{_x, _y, _z, 1.0f}}, {{_range}}} {}
friend std::ostream& operator << (std::ostream& os, const PointWithRange& p);
};
struct EIGEN_ALIGN16 _PointWithViewpoint
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
union
{
struct
{
float vp_x;
float vp_y;
float vp_z;
};
float data_c[4];
};
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointWithViewpoint& p);
/** \brief A point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen.
* \ingroup common
*/
struct EIGEN_ALIGN16 PointWithViewpoint : public _PointWithViewpoint
{
inline constexpr PointWithViewpoint (const _PointWithViewpoint &p) : PointWithViewpoint{p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z} {}
inline constexpr PointWithViewpoint (): PointWithViewpoint (0.f, 0.f, 0.f) {}
inline constexpr PointWithViewpoint (float _x, float _y, float _z): PointWithViewpoint (_x, _y, _z, 0.f, 0.f, 0.f) {}
inline constexpr PointWithViewpoint (float _x, float _y, float _z, float _vp_x, float _vp_y, float _vp_z) :
_PointWithViewpoint{{{_x, _y, _z, 1.0f}}, {{_vp_x, _vp_y, _vp_z}}} {}
friend std::ostream& operator << (std::ostream& os, const PointWithViewpoint& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const MomentInvariants& p);
/** \brief A point structure representing the three moment invariants.
* \ingroup common
*/
struct MomentInvariants
{
float j1 = 0.f, j2 = 0.f, j3 = 0.f;
inline constexpr MomentInvariants () = default;
inline constexpr MomentInvariants (float _j1, float _j2, float _j3): j1 (_j1), j2 (_j2), j3 (_j3) {}
friend std::ostream& operator << (std::ostream& os, const MomentInvariants& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PrincipalRadiiRSD& p);
/** \brief A point structure representing the minimum and maximum surface radii (in meters) computed using RSD.
* \ingroup common
*/
struct PrincipalRadiiRSD
{
float r_min = 0.f, r_max = 0.f;
inline constexpr PrincipalRadiiRSD () = default;
inline constexpr PrincipalRadiiRSD (float _r_min, float _r_max): r_min (_r_min), r_max (_r_max) {}
friend std::ostream& operator << (std::ostream& os, const PrincipalRadiiRSD& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Boundary& p);
/** \brief A point structure representing a description of whether a point is lying on a surface boundary or not.
* \ingroup common
*/
struct Boundary
{
std::uint8_t boundary_point = 0;
#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 1101
constexpr operator unsigned char() const
{
return boundary_point;
}
#endif
inline constexpr Boundary (std::uint8_t _boundary = 0): boundary_point (_boundary) {}
friend std::ostream& operator << (std::ostream& os, const Boundary& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PrincipalCurvatures& p);
/** \brief A point structure representing the principal curvatures and their magnitudes.
* \ingroup common
*/
struct PrincipalCurvatures
{
union
{
float principal_curvature[3];
struct
{
float principal_curvature_x;
float principal_curvature_y;
float principal_curvature_z;
};
};
float pc1 = 0.f;
float pc2 = 0.f;
inline constexpr PrincipalCurvatures (): PrincipalCurvatures (0.f, 0.f) {}
inline constexpr PrincipalCurvatures (float _pc1, float _pc2): PrincipalCurvatures (0.f, 0.f, 0.f, _pc1, _pc2) {}
inline constexpr PrincipalCurvatures (float _x, float _y, float _z): PrincipalCurvatures (_x, _y, _z, 0.f, 0.f) {}
inline constexpr PrincipalCurvatures (float _x, float _y, float _z, float _pc1, float _pc2):
principal_curvature_x (_x), principal_curvature_y (_y), principal_curvature_z (_z), pc1 (_pc1), pc2 (_pc2) {}
friend std::ostream& operator << (std::ostream& os, const PrincipalCurvatures& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PFHSignature125& p);
/** \brief A point structure representing the Point Feature Histogram (PFH).
* \ingroup common
*/
struct PFHSignature125
{
float histogram[125] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<PFHSignature125>; }
inline constexpr PFHSignature125 () = default;
friend std::ostream& operator << (std::ostream& os, const PFHSignature125& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PFHRGBSignature250& p);
/** \brief A point structure representing the Point Feature Histogram with colors (PFHRGB).
* \ingroup common
*/
struct PFHRGBSignature250
{
float histogram[250] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<PFHRGBSignature250>; }
inline constexpr PFHRGBSignature250 () = default;
friend std::ostream& operator << (std::ostream& os, const PFHRGBSignature250& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PPFSignature& p);
/** \brief A point structure for storing the Point Pair Feature (PPF) values
* \ingroup common
*/
struct PPFSignature
{
float f1 = 0.f, f2 = 0.f, f3 = 0.f, f4 = 0.f;
float alpha_m = 0.f;
inline constexpr PPFSignature (float _alpha = 0.f): PPFSignature (0.f, 0.f, 0.f, 0.f, _alpha) {}
inline constexpr PPFSignature (float _f1, float _f2, float _f3, float _f4, float _alpha = 0.f):
f1 (_f1), f2 (_f2), f3 (_f3), f4 (_f4), alpha_m (_alpha) {}
friend std::ostream& operator << (std::ostream& os, const PPFSignature& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const CPPFSignature& p);
/** \brief A point structure for storing the Point Pair Feature (CPPF) values
* \ingroup common
*/
struct CPPFSignature
{
float f1, f2, f3, f4, f5, f6, f7, f8, f9, f10;
float alpha_m;
inline constexpr CPPFSignature (float _alpha = 0.f):
CPPFSignature (0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, _alpha) {}
inline constexpr 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):
f1 (_f1), f2 (_f2), f3 (_f3), f4 (_f4), f5 (_f5), f6 (_f6),
f7 (_f7), f8 (_f8), f9 (_f9), f10 (_f10), alpha_m (_alpha) {}
friend std::ostream& operator << (std::ostream& os, const CPPFSignature& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PPFRGBSignature& p);
/** \brief A point structure for storing the Point Pair Color Feature (PPFRGB) values
* \ingroup common
*/
struct PPFRGBSignature
{
float f1 = 0.f, f2 = 0.f, f3 = 0.f, f4 = 0.f;
float r_ratio = 0.f, g_ratio = 0.f, b_ratio = 0.f;
float alpha_m = 0.f;
inline constexpr PPFRGBSignature (float _alpha = 0.f): PPFRGBSignature (0.f, 0.f, 0.f, 0.f, _alpha) {}
inline constexpr PPFRGBSignature (float _f1, float _f2, float _f3, float _f4, float _alpha = 0.f):
PPFRGBSignature (_f1, _f2, _f3, _f4, _alpha, 0.f, 0.f, 0.f) {}
inline constexpr PPFRGBSignature (float _f1, float _f2, float _f3, float _f4, float _alpha, float _r, float _g, float _b):
f1 (_f1), f2 (_f2), f3 (_f3), f4 (_f4), r_ratio (_r), g_ratio (_g), b_ratio (_b), alpha_m (_alpha) {}
friend std::ostream& operator << (std::ostream& os, const PPFRGBSignature& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const NormalBasedSignature12& p);
/** \brief A point structure representing the Normal Based Signature for
* a feature matrix of 4-by-3
* \ingroup common
*/
struct NormalBasedSignature12
{
float values[12] = {0.f};
inline constexpr NormalBasedSignature12 () = default;
friend std::ostream& operator << (std::ostream& os, const NormalBasedSignature12& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const ShapeContext1980& p);
/** \brief A point structure representing a Shape Context.
* \ingroup common
*/
struct ShapeContext1980
{
float descriptor[1980] = {0.f};
float rf[9] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<ShapeContext1980>; }
inline constexpr ShapeContext1980 () = default;
friend std::ostream& operator << (std::ostream& os, const ShapeContext1980& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const UniqueShapeContext1960& p);
/** \brief A point structure representing a Unique Shape Context.
* \ingroup common
*/
struct UniqueShapeContext1960
{
float descriptor[1960] = {0.f};
float rf[9] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<UniqueShapeContext1960>; }
inline constexpr UniqueShapeContext1960 () = default;
friend std::ostream& operator << (std::ostream& os, const UniqueShapeContext1960& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const SHOT352& p);
/** \brief A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape only.
* \ingroup common
*/
struct SHOT352
{
float descriptor[352] = {0.f};
float rf[9] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<SHOT352>; }
inline constexpr SHOT352 () = default;
friend std::ostream& operator << (std::ostream& os, const SHOT352& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const SHOT1344& p);
/** \brief A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+color.
* \ingroup common
*/
struct SHOT1344
{
float descriptor[1344] = {0.f};
float rf[9] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<SHOT1344>; }
inline constexpr SHOT1344 () = default;
friend std::ostream& operator << (std::ostream& os, const SHOT1344& p);
};
/** \brief A structure representing the Local Reference Frame of a point.
* \ingroup common
*/
struct EIGEN_ALIGN16 _ReferenceFrame
{
union
{
float rf[9];
struct
{
float x_axis[3];
float y_axis[3];
float z_axis[3];
};
};
inline Eigen::Map<Eigen::Vector3f> getXAxisVector3fMap () { return (Eigen::Vector3f::Map (x_axis)); }
inline const Eigen::Map<const Eigen::Vector3f> getXAxisVector3fMap () const { return (Eigen::Vector3f::Map (x_axis)); }
inline Eigen::Map<Eigen::Vector3f> getYAxisVector3fMap () { return (Eigen::Vector3f::Map (y_axis)); }
inline const Eigen::Map<const Eigen::Vector3f> getYAxisVector3fMap () const { return (Eigen::Vector3f::Map (y_axis)); }
inline Eigen::Map<Eigen::Vector3f> getZAxisVector3fMap () { return (Eigen::Vector3f::Map (z_axis)); }
inline const Eigen::Map<const Eigen::Vector3f> getZAxisVector3fMap () const { return (Eigen::Vector3f::Map (z_axis)); }
inline Eigen::Map<Eigen::Matrix3f> getMatrix3fMap () { return (Eigen::Matrix3f::Map (rf)); }
inline const Eigen::Map<const Eigen::Matrix3f> getMatrix3fMap () const { return (Eigen::Matrix3f::Map (rf)); }
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const ReferenceFrame& p);
struct EIGEN_ALIGN16 ReferenceFrame : public _ReferenceFrame
{
inline constexpr ReferenceFrame (const _ReferenceFrame &p) :
ReferenceFrame{p.rf}
{
//std::copy_n(p.rf, 9, rf); // this algorithm is constexpr starting from C++20
}
inline constexpr ReferenceFrame () :
_ReferenceFrame{ {{0.0f}} }
{
// this algorithm is constexpr starting from C++20
/*std::fill_n(x_axis, 3, 0.f);
std::fill_n(y_axis, 3, 0.f);
std::fill_n(z_axis, 3, 0.f);*/
}
inline constexpr ReferenceFrame (const float (&_rf)[9]) :
_ReferenceFrame{ {{_rf[0], _rf[1], _rf[2], _rf[3], _rf[4], _rf[5], _rf[6], _rf[7], _rf[8]}} } {}
friend std::ostream& operator << (std::ostream& os, const ReferenceFrame& p);
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const FPFHSignature33& p);
/** \brief A point structure representing the Fast Point Feature Histogram (FPFH).
* \ingroup common
*/
struct FPFHSignature33
{
float histogram[33] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<FPFHSignature33>; }
inline constexpr FPFHSignature33 () = default;
friend std::ostream& operator << (std::ostream& os, const FPFHSignature33& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const VFHSignature308& p);
/** \brief A point structure representing the Viewpoint Feature Histogram (VFH).
* \ingroup common
*/
struct VFHSignature308
{
float histogram[308] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<VFHSignature308>; }
inline constexpr VFHSignature308 () = default;
friend std::ostream& operator << (std::ostream& os, const VFHSignature308& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GRSDSignature21& p);
/** \brief A point structure representing the Global Radius-based Surface Descriptor (GRSD).
* \ingroup common
*/
struct GRSDSignature21
{
float histogram[21] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<GRSDSignature21>; }
inline constexpr GRSDSignature21 () = default;
friend std::ostream& operator << (std::ostream& os, const GRSDSignature21& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const BRISKSignature512& p);
/** \brief A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK).
* \ingroup common
*/
struct BRISKSignature512
{
float scale = 0.f;
float orientation = 0.f;
unsigned char descriptor[64] = {0};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<BRISKSignature512>; }
inline constexpr BRISKSignature512 () = default;
inline constexpr BRISKSignature512 (float _scale, float _orientation): scale (_scale), orientation (_orientation) {}
friend std::ostream& operator << (std::ostream& os, const BRISKSignature512& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const ESFSignature640& p);
/** \brief A point structure representing the Ensemble of Shape Functions (ESF).
* \ingroup common
*/
struct ESFSignature640
{
float histogram[640] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<ESFSignature640>; }
inline constexpr ESFSignature640 () = default;
friend std::ostream& operator << (std::ostream& os, const ESFSignature640& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GASDSignature512& p);
/** \brief A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor.
* \ingroup common
*/
struct GASDSignature512
{
float histogram[512] = {0.f};
static constexpr int descriptorSize() { return detail::traits::descriptorSize_v<GASDSignature512>; }
inline constexpr GASDSignature512 () = default;
friend std::ostream& operator << (std::ostream& os, const GASDSignature512& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GASDSignature984& p);
/** \brief A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor.
* \ingroup common
*/
struct GASDSignature984
{
float histogram[984] = {0.f};
static constexpr int descriptorSize() { return detail::traits::descriptorSize_v<GASDSignature984>; }
inline constexpr GASDSignature984 () = default;
friend std::ostream& operator << (std::ostream& os, const GASDSignature984& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GASDSignature7992& p);
/** \brief A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor.
* \ingroup common
*/
struct GASDSignature7992
{
float histogram[7992] = {0.f};
static constexpr int descriptorSize() { return detail::traits::descriptorSize_v<GASDSignature7992>; }
inline constexpr GASDSignature7992 () = default;
friend std::ostream& operator << (std::ostream& os, const GASDSignature7992& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const GFPFHSignature16& p);
/** \brief A point structure representing the GFPFH descriptor with 16 bins.
* \ingroup common
*/
struct GFPFHSignature16
{
float histogram[16] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<GFPFHSignature16>; }
inline constexpr GFPFHSignature16 () = default;
friend std::ostream& operator << (std::ostream& os, const GFPFHSignature16& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Narf36& p);
/** \brief A point structure representing the Narf descriptor.
* \ingroup common
*/
struct Narf36
{
float x = 0.f, y = 0.f, z = 0.f, roll = 0.f, pitch = 0.f, yaw = 0.f;
float descriptor[36] = {0.f};
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<Narf36>; }
inline constexpr Narf36 () = default;
inline constexpr Narf36 (float _x, float _y, float _z): Narf36 (_x, _y, _z, 0.f, 0.f, 0.f) {}
inline constexpr Narf36 (float _x, float _y, float _z, float _roll, float _pitch, float _yaw):
x (_x), y (_y), z (_z), roll (_roll), pitch (_pitch), yaw (_yaw) {}
friend std::ostream& operator << (std::ostream& os, const Narf36& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const BorderDescription& p);
/** \brief A structure to store if a point in a range image lies on a border between an obstacle and the background.
* \ingroup common
*/
struct BorderDescription
{
int x = 0, y = 0;
BorderTraits traits;
//std::vector<const BorderDescription*> neighbors;
inline constexpr BorderDescription () = default;
inline constexpr BorderDescription (int _x, int _y) : x(_x), y(_y) {}
friend std::ostream& operator << (std::ostream& os, const BorderDescription& p);
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const IntensityGradient& p);
/** \brief A point structure representing the intensity gradient of an XYZI point cloud.
* \ingroup common
*/
struct IntensityGradient
{
union
{
float gradient[3];
struct
{
float gradient_x;
float gradient_y;
float gradient_z;
};
};
inline constexpr IntensityGradient (): IntensityGradient (0.f, 0.f, 0.f) {}
inline constexpr IntensityGradient (float _x, float _y, float _z): gradient_x (_x), gradient_y (_y), gradient_z (_z) {}
friend std::ostream& operator << (std::ostream& os, const IntensityGradient& p);
};
// TODO: Maybe make other histogram based structs an alias for this
/** \brief A point structure representing an N-D histogram.
* \ingroup common
*/
template <int N>
struct Histogram
{
float histogram[N];
static constexpr int descriptorSize () { return detail::traits::descriptorSize_v<Histogram<N>>; }
};
struct EIGEN_ALIGN16 _PointWithScale
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
union
{
/** \brief Diameter of the meaningful keypoint neighborhood. */
float scale;
float size;
};
/** \brief Computed orientation of the keypoint (-1 if not applicable). */
float angle;
/** \brief The response by which the most strong keypoints have been selected. */
float response;
/** \brief octave (pyramid layer) from which the keypoint has been extracted. */
int octave;
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointWithScale& p);
/** \brief A point structure representing a 3-D position and scale.
* \ingroup common
*/
struct PointWithScale : public _PointWithScale
{
inline constexpr PointWithScale (const _PointWithScale &p) :
PointWithScale{p.x, p.y, p.z, p.scale, p.angle, p.response, p.octave} {}
inline constexpr PointWithScale (): PointWithScale (0.f, 0.f, 0.f) {}
inline constexpr PointWithScale (float _x, float _y, float _z, float _scale = 1.f,
float _angle = -1.f, float _response = 0.f, int _octave = 0) :
_PointWithScale{{{_x, _y, _z, 1.0f}}, {_scale}, _angle, _response, _octave } {}
friend std::ostream& operator << (std::ostream& os, const PointWithScale& p);
};
struct EIGEN_ALIGN16 _PointSurfel
{
PCL_ADD_POINT4D // This adds the members x,y,z which can also be accessed using the point (which is float[4])
PCL_ADD_NORMAL4D // This adds the member normal[3] which can also be accessed using the point (which is float[4])
union
{
struct
{
PCL_ADD_UNION_RGB
float radius;
float confidence;
float curvature;
};
float data_c[4];
};
PCL_ADD_EIGEN_MAPS_RGB
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointSurfel& p);
/** \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.
* \ingroup common
*/
struct PointSurfel : public _PointSurfel
{
inline constexpr PointSurfel (const _PointSurfel &p) :
PointSurfel{p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.r, p.g, p.b, p.a, p.radius, p.confidence, p.curvature} {}
inline constexpr PointSurfel () :
PointSurfel{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0u, 0u, 0u, 0u, 0.0f, 0.0f, 0.0f} {}
inline constexpr PointSurfel (float _x, float _y, float _z, float _nx,
float _ny, float _nz, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a,
float _radius, float _confidence, float _curvature) :
_PointSurfel{
{{_x, _y, _z, 1.0f}},
{{_nx, _ny, _nz, 0.0f}},
{{{{{_b, _g, _r, _a}}}, _radius, _confidence, _curvature}}
} {}
friend std::ostream& operator << (std::ostream& os, const PointSurfel& p);
};
struct EIGEN_ALIGN16 _PointDEM
{
PCL_ADD_POINT4D
float intensity;
float intensity_variance;
float height_variance;
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
PCL_EXPORTS std::ostream& operator << (std::ostream& os, const PointDEM& p);
/** \brief A point structure representing Digital Elevation Map.
* \ingroup common
*/
struct PointDEM : public _PointDEM
{
inline constexpr PointDEM (const _PointDEM &p) :
PointDEM{p.x, p.y, p.z, p.intensity, p.intensity_variance, p.height_variance} {}
inline constexpr PointDEM (): PointDEM (0.f, 0.f, 0.f) {}
inline constexpr PointDEM (float _x, float _y, float _z): PointDEM (_x, _y, _z, 0.f, 0.f, 0.f) {}
inline constexpr PointDEM (float _x, float _y, float _z, float _intensity,
float _intensity_variance, float _height_variance) :
_PointDEM{{{_x, _y, _z, 1.0f}}, _intensity, _intensity_variance, _height_variance} {}
friend std::ostream& operator << (std::ostream& os, const PointDEM& p);
};
template <int N> std::ostream&
operator << (std::ostream& os, const Histogram<N>& p)
{
// make constexpr
PCL_IF_CONSTEXPR(N > 0)
{
os << "(" << p.histogram[0];
std::for_each(p.histogram + 1, std::end(p.histogram),
[&os](const auto& hist) { os << ", " << hist; });
os << ")";
}
return (os);
}
} // namespace pcl
// Register point structs and wrappers
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_RGB,
(std::uint32_t, rgba, rgba)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::RGB, pcl::_RGB)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_Intensity,
(float, intensity, intensity)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity, pcl::_Intensity)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_Intensity8u,
(std::uint8_t, intensity, intensity)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity8u, pcl::_Intensity8u)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_Intensity32u,
(std::uint32_t, intensity, intensity)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Intensity32u, pcl::_Intensity32u)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZ,
(float, x, x)
(float, y, y)
(float, z, z)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZ, pcl::_PointXYZ)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZRGBA,
(float, x, x)
(float, y, y)
(float, z, z)
(std::uint32_t, rgba, rgba)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBA, pcl::_PointXYZRGBA)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZRGB,
(float, x, x)
(float, y, y)
(float, z, z)
(float, rgb, rgb)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGB, pcl::_PointXYZRGB)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZRGBL,
(float, x, x)
(float, y, y)
(float, z, z)
(std::uint32_t, rgba, rgba)
(std::uint32_t, label, label)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBL, pcl::_PointXYZRGBL)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZLAB,
(float, x, x)
(float, y, y)
(float, z, z)
(float, L, L)
(float, a, a)
(float, b, b)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZLAB, pcl::_PointXYZLAB)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZHSV,
(float, x, x)
(float, y, y)
(float, z, z)
(float, h, h)
(float, s, s)
(float, v, v)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZHSV, pcl::_PointXYZHSV)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointXY,
(float, x, x)
(float, y, y)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointUV,
(float, u, u)
(float, v, v)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::InterestPoint,
(float, x, x)
(float, y, y)
(float, z, z)
(float, strength, strength)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZI,
(float, x, x)
(float, y, y)
(float, z, z)
(float, intensity, intensity)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZI, pcl::_PointXYZI)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointXYZL,
(float, x, x)
(float, y, y)
(float, z, z)
(std::uint32_t, label, label)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::Label,
(std::uint32_t, label, label)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_Normal,
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(float, curvature, curvature)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Normal, pcl::_Normal)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_Axis,
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::Axis, pcl::_Axis)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointNormal,
(float, x, x)
(float, y, y)
(float, z, z)
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(float, curvature, curvature)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointXYZRGBNormal,
(float, x, x)
(float, y, y)
(float, z, z)
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(float, rgb, rgb)
(float, curvature, curvature)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZRGBNormal, pcl::_PointXYZRGBNormal)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointXYZINormal,
(float, x, x)
(float, y, y)
(float, z, z)
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(float, intensity, intensity)
(float, curvature, curvature)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointXYZLNormal,
(float, x, x)
(float, y, y)
(float, z, z)
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(std::uint32_t, label, label)
(float, curvature, curvature)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointWithRange,
(float, x, x)
(float, y, y)
(float, z, z)
(float, range, range)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointWithViewpoint,
(float, x, x)
(float, y, y)
(float, z, z)
(float, vp_x, vp_x)
(float, vp_y, vp_y)
(float, vp_z, vp_z)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointWithViewpoint, pcl::_PointWithViewpoint)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::MomentInvariants,
(float, j1, j1)
(float, j2, j2)
(float, j3, j3)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PrincipalRadiiRSD,
(float, r_min, r_min)
(float, r_max, r_max)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::Boundary,
(std::uint8_t, boundary_point, boundary_point)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PrincipalCurvatures,
(float, principal_curvature_x, principal_curvature_x)
(float, principal_curvature_y, principal_curvature_y)
(float, principal_curvature_z, principal_curvature_z)
(float, pc1, pc1)
(float, pc2, pc2)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PFHSignature125,
(float[125], histogram, pfh)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PFHRGBSignature250,
(float[250], histogram, pfhrgb)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PPFSignature,
(float, f1, f1)
(float, f2, f2)
(float, f3, f3)
(float, f4, f4)
(float, alpha_m, alpha_m)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::CPPFSignature,
(float, f1, f1)
(float, f2, f2)
(float, f3, f3)
(float, f4, f4)
(float, f5, f5)
(float, f6, f6)
(float, f7, f7)
(float, f8, f8)
(float, f9, f9)
(float, f10, f10)
(float, alpha_m, alpha_m)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PPFRGBSignature,
(float, f1, f1)
(float, f2, f2)
(float, f3, f3)
(float, f4, f4)
(float, r_ratio, r_ratio)
(float, g_ratio, g_ratio)
(float, b_ratio, b_ratio)
(float, alpha_m, alpha_m)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::NormalBasedSignature12,
(float[12], values, values)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::ShapeContext1980,
(float[1980], descriptor, shape_context)
(float[9], rf, rf)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::UniqueShapeContext1960,
(float[1960], descriptor, shape_context)
(float[9], rf, rf)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::SHOT352,
(float[352], descriptor, shot)
(float[9], rf, rf)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::SHOT1344,
(float[1344], descriptor, shot)
(float[9], rf, rf)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::FPFHSignature33,
(float[33], histogram, fpfh)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::BRISKSignature512,
(float, scale, brisk_scale)
(float, orientation, brisk_orientation)
(unsigned char[64], descriptor, brisk_descriptor512)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::VFHSignature308,
(float[308], histogram, vfh)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::GRSDSignature21,
(float[21], histogram, grsd)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::ESFSignature640,
(float[640], histogram, esf)
)
POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::GASDSignature512,
(float[512], histogram, gasd)
)
POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::GASDSignature984,
(float[984], histogram, gasd)
)
POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::GASDSignature7992,
(float[7992], histogram, gasd)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::Narf36,
(float[36], descriptor, descriptor)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::GFPFHSignature16,
(float[16], histogram, gfpfh)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::IntensityGradient,
(float, gradient_x, gradient_x)
(float, gradient_y, gradient_y)
(float, gradient_z, gradient_z)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointWithScale,
(float, x, x)
(float, y, y)
(float, z, z)
(float, scale, scale)
)
POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::PointSurfel,
(float, x, x)
(float, y, y)
(float, z, z)
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(std::uint32_t, rgba, rgba)
(float, radius, radius)
(float, confidence, confidence)
(float, curvature, curvature)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_ReferenceFrame,
(float[3], x_axis, x_axis)
(float[3], y_axis, y_axis)
(float[3], z_axis, z_axis)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::ReferenceFrame, pcl::_ReferenceFrame)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::_PointDEM,
(float, x, x)
(float, y, y)
(float, z, z)
(float, intensity, intensity)
(float, intensity_variance, intensity_variance)
(float, height_variance, height_variance)
)
POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointDEM, pcl::_PointDEM)
namespace pcl
{
// Allow float 'rgb' data to match to the newer uint32 'rgba' tag. This is so
// you can load old 'rgb' PCD files into e.g. a PointCloud<PointXYZRGBA>.
template<typename PointT>
struct FieldMatches<PointT, ::pcl::fields::rgba>
{
bool operator() (const pcl::PCLPointField& field)
{
if (field.name == "rgb")
{
// For fixing the alpha value bug #1141, the rgb field can also match
// uint32.
return ((field.datatype == pcl::PCLPointField::FLOAT32 ||
field.datatype == pcl::PCLPointField::UINT32) &&
field.count == 1);
}
else
{
return (field.name == traits::name<PointT, fields::rgba>::value &&
field.datatype == traits::datatype<PointT, fields::rgba>::value &&
field.count == traits::datatype<PointT, fields::rgba>::size);
}
}
};
template<typename PointT>
struct FieldMatches<PointT, fields::rgb>
{
bool operator() (const pcl::PCLPointField& field)
{
if (field.name == "rgba")
{
return (field.datatype == pcl::PCLPointField::UINT32 &&
field.count == 1);
}
else
{
// For fixing the alpha value bug #1141, rgb can also match uint32
return (field.name == traits::name<PointT, fields::rgb>::value &&
(field.datatype == traits::datatype<PointT, fields::rgb>::value ||
field.datatype == pcl::PCLPointField::UINT32) &&
field.count == traits::datatype<PointT, fields::rgb>::size);
}
}
};
// We're doing a lot of black magic with Boost here, so disable warnings in Maintainer mode, as we will never
// be able to fix them anyway
#if defined _MSC_VER
#pragma warning(disable: 4201)
#endif
namespace traits
{
/** \brief Metafunction to check if a given point type has a given field.
*
* Example usage at run-time:
*
* \code
* bool curvature_available = pcl::traits::has_field<PointT, pcl::fields::curvature>::value;
* \endcode
*
* Example usage at compile-time:
*
* \code
* BOOST_MPL_ASSERT_MSG ((pcl::traits::has_field<PointT, pcl::fields::label>::value),
* POINT_TYPE_SHOULD_HAVE_LABEL_FIELD,
* (PointT));
* \endcode
*/
template <typename PointT, typename Field>
struct has_field : boost::mpl::contains<typename pcl::traits::fieldList<PointT>::type, Field>::type
{ };
/** Metafunction to check if a given point type has all given fields. */
template <typename PointT, typename Field>
struct has_all_fields : boost::mpl::fold<Field,
boost::mpl::bool_<true>,
boost::mpl::and_<boost::mpl::_1,
has_field<PointT, boost::mpl::_2> > >::type
{ };
/** Metafunction to check if a given point type has any of the given fields. */
template <typename PointT, typename Field>
struct has_any_field : boost::mpl::fold<Field,
boost::mpl::bool_<false>,
boost::mpl::or_<boost::mpl::_1,
has_field<PointT, boost::mpl::_2> > >::type
{ };
/** \brief Traits defined for ease of use with fields already registered before
*
* has_<fields to be detected>: struct with `value` datamember defined at compiletime
* has_<fields to be detected>_v: constexpr boolean
* Has<Fields to be detected>: concept modelling name alias for `enable_if`
*/
/** Metafunction to check if a given point type has x and y fields. */
template <typename PointT>
struct has_xy : has_all_fields<PointT, boost::mpl::vector<pcl::fields::x,
pcl::fields::y> >
{ };
template <typename PointT>
constexpr auto has_xy_v = has_xy<PointT>::value;
template <typename PointT>
using HasXY = std::enable_if_t<has_xy_v<PointT>, bool>;
template <typename PointT>
using HasNoXY = std::enable_if_t<!has_xy_v<PointT>, bool>;
/** Metafunction to check if a given point type has x, y, and z fields. */
template <typename PointT>
struct has_xyz : has_all_fields<PointT, boost::mpl::vector<pcl::fields::x,
pcl::fields::y,
pcl::fields::z> >
{ };
template <typename PointT>
constexpr auto has_xyz_v = has_xyz<PointT>::value;
template <typename PointT>
using HasXYZ = std::enable_if_t<has_xyz_v<PointT>, bool>;
template <typename PointT>
using HasNoXYZ = std::enable_if_t<!has_xyz_v<PointT>, bool>;
/** Metafunction to check if a given point type has normal_x, normal_y, and
* normal_z fields. */
template <typename PointT>
struct has_normal : has_all_fields<PointT, boost::mpl::vector<pcl::fields::normal_x,
pcl::fields::normal_y,
pcl::fields::normal_z> >
{ };
template <typename PointT>
constexpr auto has_normal_v = has_normal<PointT>::value;
template <typename PointT>
using HasNormal = std::enable_if_t<has_normal_v<PointT>, bool>;
template <typename PointT>
using HasNoNormal = std::enable_if_t<!has_normal_v<PointT>, bool>;
/** Metafunction to check if a given point type has curvature field. */
template <typename PointT>
struct has_curvature : has_field<PointT, pcl::fields::curvature>
{ };
template <typename PointT>
constexpr auto has_curvature_v = has_curvature<PointT>::value;
template <typename PointT>
using HasCurvature = std::enable_if_t<has_curvature_v<PointT>, bool>;
template <typename PointT>
using HasNoCurvature = std::enable_if_t<!has_curvature_v<PointT>, bool>;
/** Metafunction to check if a given point type has intensity field. */
template <typename PointT>
struct has_intensity : has_field<PointT, pcl::fields::intensity>
{ };
template <typename PointT>
constexpr auto has_intensity_v = has_intensity<PointT>::value;
template <typename PointT>
using HasIntensity = std::enable_if_t<has_intensity_v<PointT>, bool>;
template <typename PointT>
using HasNoIntensity = std::enable_if_t<!has_intensity_v<PointT>, bool>;
/** Metafunction to check if a given point type has either rgb or rgba field. */
template <typename PointT>
struct has_color : has_any_field<PointT, boost::mpl::vector<pcl::fields::rgb,
pcl::fields::rgba> >
{ };
template <typename PointT>
constexpr auto has_color_v = has_color<PointT>::value;
template <typename PointT>
using HasColor = std::enable_if_t<has_color_v<PointT>, bool>;
template <typename PointT>
using HasNoColor = std::enable_if_t<!has_color_v<PointT>, bool>;
/** Metafunction to check if a given point type has label field. */
template <typename PointT>
struct has_label : has_field<PointT, pcl::fields::label>
{ };
template <typename PointT>
constexpr auto has_label_v = has_label<PointT>::value;
template <typename PointT>
using HasLabel = std::enable_if_t<has_label_v<PointT>, bool>;
template <typename PointT>
using HasNoLabel = std::enable_if_t<!has_label_v<PointT>, bool>;
}
#if defined _MSC_VER
#pragma warning(default: 4201)
#endif
} // namespace pcl
point_types.h
Defines all the PCL implemented PointT point type structures.
PCL_MAKE_ALIGNED_OPERATOR_NEW
#define PCL_MAKE_ALIGNED_OPERATOR_NEW
Macro to signal a class requires a custom allocator.
Definition memory.h:86
pcl::BorderTraits
std::bitset< 32 > BorderTraits
Data type to store extended information about a transition from foreground to backgroundSpecification...
Definition point_types.h:307
memory.h
Defines functions, macros and traits for allocating and using memory.
pcl::detail::traits
Definition point_types.hpp:166
pcl::detail::traits::descriptorSize_v
static constexpr int descriptorSize_v
Definition point_types.hpp:189
pcl::detail
Definition accumulators.hpp:57
pcl::fields
Definition type_traits.h:60
pcl::traits
Definition register_point_struct.h:90
pcl
Definition convolution.h:46
pcl::Vector4fMap
Eigen::Map< Eigen::Vector4f, Eigen::Aligned > Vector4fMap
Definition point_types.hpp:201
pcl::Vector3fMapConst
const Eigen::Map< const Eigen::Vector3f > Vector3fMapConst
Definition point_types.hpp:200
pcl::Vector3cMap
Eigen::Map< Vector3c > Vector3cMap
Definition point_types.hpp:205
pcl::Array4fMapConst
const Eigen::Map< const Eigen::Array4f, Eigen::Aligned > Array4fMapConst
Definition point_types.hpp:198
pcl::Vector2fMap
Eigen::Map< Eigen::Vector2f > Vector2fMap
Definition point_types.hpp:193
pcl::operator<<
std::ostream & operator<<(std::ostream &os, const BivariatePolynomialT< real > &p)
Definition bivariate_polynomial.hpp:238
pcl::Array4fMap
Eigen::Map< Eigen::Array4f, Eigen::Aligned > Array4fMap
Definition point_types.hpp:197
pcl::Vector3cMapConst
const Eigen::Map< const Vector3c > Vector3cMapConst
Definition point_types.hpp:206
pcl::Vector2fMapConst
const Eigen::Map< const Eigen::Vector2f > Vector2fMapConst
Definition point_types.hpp:194
pcl::Vector4c
Eigen::Matrix< std::uint8_t, 4, 1 > Vector4c
Definition point_types.hpp:207
pcl::Array3fMap
Eigen::Map< Eigen::Array3f > Array3fMap
Definition point_types.hpp:195
pcl::Vector4cMapConst
const Eigen::Map< const Vector4c, Eigen::Aligned > Vector4cMapConst
Definition point_types.hpp:209
pcl::Vector3fMap
Eigen::Map< Eigen::Vector3f > Vector3fMap
Definition point_types.hpp:199
pcl::Vector4cMap
Eigen::Map< Vector4c, Eigen::Aligned > Vector4cMap
Definition point_types.hpp:208
pcl::Vector4fMapConst
const Eigen::Map< const Eigen::Vector4f, Eigen::Aligned > Vector4fMapConst
Definition point_types.hpp:202
pcl::Array3fMapConst
const Eigen::Map< const Eigen::Array3f > Array3fMapConst
Definition point_types.hpp:196
pcl::Vector3c
Eigen::Matrix< std::uint8_t, 3, 1 > Vector3c
Definition point_types.hpp:204
pcl_macros.h
Defines all the PCL and non-PCL macros used.
PCL_IF_CONSTEXPR
#define PCL_IF_CONSTEXPR(x)
Definition pcl_macros.h:454
pcl::_Axis
Definition point_types.hpp:808
pcl::_Intensity32u
Definition point_types.hpp:420
pcl::_Intensity32u::PCL_ADD_INTENSITY_32U
PCL_ADD_INTENSITY_32U
Definition point_types.hpp:421
pcl::_Intensity8u
Definition point_types.hpp:394
pcl::_Intensity8u::PCL_ADD_INTENSITY_8U
PCL_ADD_INTENSITY_8U
Definition point_types.hpp:395
pcl::_Intensity
Definition point_types.hpp:374
pcl::_Normal
Definition point_types.hpp:776
pcl::_Normal::data_c
float data_c[4]
Definition point_types.hpp:784
pcl::_Normal::curvature
float curvature
Definition point_types.hpp:782
pcl::_PointDEM
Definition point_types.hpp:1689
pcl::_PointDEM::intensity_variance
float intensity_variance
Definition point_types.hpp:1692
pcl::_PointDEM::intensity
PCL_ADD_POINT4D float intensity
Definition point_types.hpp:1691
pcl::_PointDEM::height_variance
float height_variance
Definition point_types.hpp:1693
pcl::_PointNormal
Definition point_types.hpp:831
pcl::_PointNormal::data_c
float data_c[4]
Definition point_types.hpp:840
pcl::_PointNormal::curvature
float curvature
Definition point_types.hpp:838
pcl::_PointSurfel
Definition point_types.hpp:1645
pcl::_PointSurfel::data_c
float data_c[4]
Definition point_types.hpp:1657
pcl::_PointSurfel::curvature
float curvature
Definition point_types.hpp:1655
pcl::_PointSurfel::radius
PCL_ADD_UNION_RGB float radius
Definition point_types.hpp:1653
pcl::_PointSurfel::confidence
float confidence
Definition point_types.hpp:1654
pcl::_PointWithRange
Definition point_types.hpp:1040
pcl::_PointWithRange::data_c
float data_c[4]
Definition point_types.hpp:1048
pcl::_PointWithRange::range
float range
Definition point_types.hpp:1046
pcl::_PointWithScale
Definition point_types.hpp:1605
pcl::_PointWithScale::angle
float angle
Computed orientation of the keypoint (-1 if not applicable).
Definition point_types.hpp:1616
pcl::_PointWithScale::response
float response
The response by which the most strong keypoints have been selected.
Definition point_types.hpp:1618
pcl::_PointWithScale::octave
int octave
octave (pyramid layer) from which the keypoint has been extracted.
Definition point_types.hpp:1620
pcl::_PointWithScale::scale
float scale
Diameter of the meaningful keypoint neighborhood.
Definition point_types.hpp:1611
pcl::_PointWithScale::size
float size
Definition point_types.hpp:1612
pcl::_PointWithViewpoint
Definition point_types.hpp:1071
pcl::_PointWithViewpoint::data_c
float data_c[4]
Definition point_types.hpp:1081
pcl::_PointWithViewpoint::vp_z
float vp_z
Definition point_types.hpp:1079
pcl::_PointWithViewpoint::vp_y
float vp_y
Definition point_types.hpp:1078
pcl::_PointWithViewpoint::vp_x
float vp_x
Definition point_types.hpp:1077
pcl::_PointXYZHSV
Definition point_types.hpp:674
pcl::_PointXYZHSV::data_c
float data_c[4]
Definition point_types.hpp:684
pcl::_PointXYZHSV::v
float v
Definition point_types.hpp:682
pcl::_PointXYZHSV::h
float h
Definition point_types.hpp:680
pcl::_PointXYZHSV::s
float s
Definition point_types.hpp:681
pcl::_PointXYZ
Definition point_types.hpp:311
pcl::_PointXYZI
A point structure representing Euclidean xyz coordinates, and the intensity value.
Definition point_types.hpp:442
pcl::_PointXYZI::data_c
float data_c[4]
Definition point_types.hpp:450
pcl::_PointXYZI::intensity
float intensity
Definition point_types.hpp:448
pcl::_PointXYZINormal
Definition point_types.hpp:952
pcl::_PointXYZINormal::intensity
float intensity
Definition point_types.hpp:959
pcl::_PointXYZINormal::data_c
float data_c[4]
Definition point_types.hpp:962
pcl::_PointXYZINormal::curvature
float curvature
Definition point_types.hpp:960
pcl::_PointXYZLAB
Definition point_types.hpp:639
pcl::_PointXYZLAB::a
float a
Definition point_types.hpp:646
pcl::_PointXYZLAB::b
float b
Definition point_types.hpp:647
pcl::_PointXYZLAB::data_lab
float data_lab[4]
Definition point_types.hpp:649
pcl::_PointXYZLAB::L
float L
Definition point_types.hpp:645
pcl::_PointXYZL
Definition point_types.hpp:469
pcl::_PointXYZL::label
PCL_ADD_POINT4D std::uint32_t label
Definition point_types.hpp:471
pcl::_PointXYZLNormal
Definition point_types.hpp:995
pcl::_PointXYZLNormal::curvature
float curvature
Definition point_types.hpp:1003
pcl::_PointXYZLNormal::data_c
float data_c[4]
Definition point_types.hpp:1005
pcl::_PointXYZLNormal::label
std::uint32_t label
Definition point_types.hpp:1002
pcl::_PointXYZRGBA
Definition point_types.hpp:500
pcl::_PointXYZRGB
Definition point_types.hpp:547
pcl::_PointXYZRGBL
Definition point_types.hpp:554
pcl::_PointXYZRGBL::label
PCL_ADD_POINT4D PCL_ADD_RGB std::uint32_t label
Definition point_types.hpp:557
pcl::_PointXYZRGBNormal
Definition point_types.hpp:866
pcl::_PointXYZRGBNormal::curvature
PCL_ADD_UNION_RGB float curvature
Definition point_types.hpp:874
pcl::_PointXYZRGBNormal::data_c
float data_c[4]
Definition point_types.hpp:876
pcl::_RGB
Definition point_types.hpp:338
pcl::_ReferenceFrame
A structure representing the Local Reference Frame of a point.
Definition point_types.hpp:1352
pcl::_ReferenceFrame::x_axis
float x_axis[3]
Definition point_types.hpp:1358
pcl::_ReferenceFrame::getZAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getZAxisVector3fMap()
Definition point_types.hpp:1368
pcl::_ReferenceFrame::getXAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getXAxisVector3fMap()
Definition point_types.hpp:1364
pcl::_ReferenceFrame::getYAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getYAxisVector3fMap()
Definition point_types.hpp:1366
pcl::_ReferenceFrame::y_axis
float y_axis[3]
Definition point_types.hpp:1359
pcl::_ReferenceFrame::getYAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getYAxisVector3fMap() const
Definition point_types.hpp:1367
pcl::_ReferenceFrame::rf
float rf[9]
Definition point_types.hpp:1355
pcl::_ReferenceFrame::getMatrix3fMap
Eigen::Map< Eigen::Matrix3f > getMatrix3fMap()
Definition point_types.hpp:1370
pcl::_ReferenceFrame::getZAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getZAxisVector3fMap() const
Definition point_types.hpp:1369
pcl::_ReferenceFrame::getXAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getXAxisVector3fMap() const
Definition point_types.hpp:1365
pcl::_ReferenceFrame::z_axis
float z_axis[3]
Definition point_types.hpp:1360
pcl::_ReferenceFrame::getMatrix3fMap
const Eigen::Map< const Eigen::Matrix3f > getMatrix3fMap() const
Definition point_types.hpp:1371
pcl::Axis
A point structure representing an Axis using its normal coordinates.
Definition point_types.hpp:818
pcl::Axis::Axis
constexpr Axis(float n_x, float n_y, float n_z)
Definition point_types.hpp:823
pcl::Axis::Axis
constexpr Axis()
Definition point_types.hpp:821
pcl::Axis::Axis
constexpr Axis(const _Axis &p)
Definition point_types.hpp:819
pcl::BRISKSignature512
A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK).
Definition point_types.hpp:1449
pcl::BRISKSignature512::scale
float scale
Definition point_types.hpp:1450
pcl::BRISKSignature512::BRISKSignature512
constexpr BRISKSignature512()=default
pcl::BRISKSignature512::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1453
pcl::BRISKSignature512::BRISKSignature512
constexpr BRISKSignature512(float _scale, float _orientation)
Definition point_types.hpp:1457
pcl::BRISKSignature512::orientation
float orientation
Definition point_types.hpp:1451
pcl::BRISKSignature512::descriptor
unsigned char descriptor[64]
Definition point_types.hpp:1452
pcl::BorderDescription
A structure to store if a point in a range image lies on a border between an obstacle and the backgro...
Definition point_types.hpp:1557
pcl::BorderDescription::y
int y
Definition point_types.hpp:1558
pcl::BorderDescription::BorderDescription
constexpr BorderDescription(int _x, int _y)
Definition point_types.hpp:1564
pcl::BorderDescription::traits
BorderTraits traits
Definition point_types.hpp:1559
pcl::BorderDescription::BorderDescription
constexpr BorderDescription()=default
pcl::BorderDescription::x
int x
Definition point_types.hpp:1558
pcl::Boundary
A point structure representing a description of whether a point is lying on a surface boundary or not...
Definition point_types.hpp:1139
pcl::Boundary::Boundary
constexpr Boundary(std::uint8_t _boundary=0)
Definition point_types.hpp:1149
pcl::Boundary::boundary_point
std::uint8_t boundary_point
Definition point_types.hpp:1140
pcl::CPPFSignature
A point structure for storing the Point Pair Feature (CPPF) values.
Definition point_types.hpp:1236
pcl::CPPFSignature::CPPFSignature
constexpr CPPFSignature(float _alpha=0.f)
Definition point_types.hpp:1240
pcl::CPPFSignature::f2
float f2
Definition point_types.hpp:1237
pcl::CPPFSignature::f8
float f8
Definition point_types.hpp:1237
pcl::CPPFSignature::f9
float f9
Definition point_types.hpp:1237
pcl::CPPFSignature::f4
float f4
Definition point_types.hpp:1237
pcl::CPPFSignature::f5
float f5
Definition point_types.hpp:1237
pcl::CPPFSignature::f1
float f1
Definition point_types.hpp:1237
pcl::CPPFSignature::alpha_m
float alpha_m
Definition point_types.hpp:1238
pcl::CPPFSignature::f7
float f7
Definition point_types.hpp:1237
pcl::CPPFSignature::f6
float f6
Definition point_types.hpp:1237
pcl::CPPFSignature::CPPFSignature
constexpr CPPFSignature(float _f1, float _f2, float _f3, float _f4, float _f5, float _f6, float _f7, float _f8, float _f9, float _f10, float _alpha=0.f)
Definition point_types.hpp:1243
pcl::CPPFSignature::f10
float f10
Definition point_types.hpp:1237
pcl::CPPFSignature::f3
float f3
Definition point_types.hpp:1237
pcl::ESFSignature640
A point structure representing the Ensemble of Shape Functions (ESF).
Definition point_types.hpp:1467
pcl::ESFSignature640::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1469
pcl::ESFSignature640::ESFSignature640
constexpr ESFSignature640()=default
pcl::ESFSignature640::histogram
float histogram[640]
Definition point_types.hpp:1468
pcl::FPFHSignature33
A point structure representing the Fast Point Feature Histogram (FPFH).
Definition point_types.hpp:1407
pcl::FPFHSignature33::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1409
pcl::FPFHSignature33::FPFHSignature33
constexpr FPFHSignature33()=default
pcl::FPFHSignature33::histogram
float histogram[33]
Definition point_types.hpp:1408
pcl::FieldMatches
Definition PCLPointField.h:70
pcl::FieldMatches::operator()
bool operator()(const PCLPointField &field)
Definition PCLPointField.h:71
pcl::GASDSignature512
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor.
Definition point_types.hpp:1481
pcl::GASDSignature512::histogram
float histogram[512]
Definition point_types.hpp:1482
pcl::GASDSignature512::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1483
pcl::GASDSignature512::GASDSignature512
constexpr GASDSignature512()=default
pcl::GASDSignature7992
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descr...
Definition point_types.hpp:1509
pcl::GASDSignature7992::histogram
float histogram[7992]
Definition point_types.hpp:1510
pcl::GASDSignature7992::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1511
pcl::GASDSignature7992::GASDSignature7992
constexpr GASDSignature7992()=default
pcl::GASDSignature984
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descr...
Definition point_types.hpp:1495
pcl::GASDSignature984::histogram
float histogram[984]
Definition point_types.hpp:1496
pcl::GASDSignature984::GASDSignature984
constexpr GASDSignature984()=default
pcl::GASDSignature984::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1497
pcl::GFPFHSignature16
A point structure representing the GFPFH descriptor with 16 bins.
Definition point_types.hpp:1523
pcl::GFPFHSignature16::GFPFHSignature16
constexpr GFPFHSignature16()=default
pcl::GFPFHSignature16::histogram
float histogram[16]
Definition point_types.hpp:1524
pcl::GFPFHSignature16::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1525
pcl::GRSDSignature21
A point structure representing the Global Radius-based Surface Descriptor (GRSD).
Definition point_types.hpp:1435
pcl::GRSDSignature21::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1437
pcl::GRSDSignature21::histogram
float histogram[21]
Definition point_types.hpp:1436
pcl::GRSDSignature21::GRSDSignature21
constexpr GRSDSignature21()=default
pcl::Histogram
A point structure representing an N-D histogram.
Definition point_types.hpp:1599
pcl::Histogram::histogram
float histogram[N]
Definition point_types.hpp:1600
pcl::Histogram::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1601
pcl::Intensity32u
A point structure representing the grayscale intensity in single-channel images.
Definition point_types.hpp:430
pcl::Intensity32u::Intensity32u
constexpr Intensity32u(const _Intensity32u &p)
Definition point_types.hpp:431
pcl::Intensity32u::Intensity32u
constexpr Intensity32u(std::uint32_t _intensity=0)
Definition point_types.hpp:433
pcl::Intensity8u
A point structure representing the grayscale intensity in single-channel images.
Definition point_types.hpp:404
pcl::Intensity8u::Intensity8u
constexpr Intensity8u(std::uint8_t _intensity=0)
Definition point_types.hpp:407
pcl::Intensity8u::Intensity8u
constexpr Intensity8u(const _Intensity8u &p)
Definition point_types.hpp:405
pcl::IntensityGradient
A point structure representing the intensity gradient of an XYZI point cloud.
Definition point_types.hpp:1575
pcl::IntensityGradient::gradient
float gradient[3]
Definition point_types.hpp:1578
pcl::IntensityGradient::gradient_x
float gradient_x
Definition point_types.hpp:1581
pcl::IntensityGradient::IntensityGradient
constexpr IntensityGradient(float _x, float _y, float _z)
Definition point_types.hpp:1589
pcl::IntensityGradient::gradient_z
float gradient_z
Definition point_types.hpp:1583
pcl::IntensityGradient::gradient_y
float gradient_y
Definition point_types.hpp:1582
pcl::IntensityGradient::IntensityGradient
constexpr IntensityGradient()
Definition point_types.hpp:1587
pcl::Intensity
A point structure representing the grayscale intensity in single-channel images.
Definition point_types.hpp:384
pcl::Intensity::Intensity
constexpr Intensity(const _Intensity &p)
Definition point_types.hpp:385
pcl::Intensity::Intensity
constexpr Intensity(float _intensity=0.f)
Definition point_types.hpp:387
pcl::InterestPoint
A point structure representing an interest point with Euclidean xyz coordinates, and an interest valu...
Definition point_types.hpp:760
pcl::InterestPoint::strength
float strength
Definition point_types.hpp:766
pcl::InterestPoint::data_c
float data_c[4]
Definition point_types.hpp:768
pcl::Label
Definition point_types.hpp:490
pcl::Label::Label
constexpr Label(std::uint32_t _label=0)
Definition point_types.hpp:493
pcl::Label::label
std::uint32_t label
Definition point_types.hpp:491
pcl::MomentInvariants
A point structure representing the three moment invariants.
Definition point_types.hpp:1109
pcl::MomentInvariants::MomentInvariants
constexpr MomentInvariants()=default
pcl::MomentInvariants::j1
float j1
Definition point_types.hpp:1110
pcl::MomentInvariants::j2
float j2
Definition point_types.hpp:1110
pcl::MomentInvariants::MomentInvariants
constexpr MomentInvariants(float _j1, float _j2, float _j3)
Definition point_types.hpp:1114
pcl::MomentInvariants::j3
float j3
Definition point_types.hpp:1110
pcl::Narf36
A point structure representing the Narf descriptor.
Definition point_types.hpp:1537
pcl::Narf36::Narf36
constexpr Narf36(float _x, float _y, float _z, float _roll, float _pitch, float _yaw)
Definition point_types.hpp:1546
pcl::Narf36::roll
float roll
Definition point_types.hpp:1538
pcl::Narf36::pitch
float pitch
Definition point_types.hpp:1538
pcl::Narf36::z
float z
Definition point_types.hpp:1538
pcl::Narf36::y
float y
Definition point_types.hpp:1538
pcl::Narf36::yaw
float yaw
Definition point_types.hpp:1538
pcl::Narf36::descriptor
float descriptor[36]
Definition point_types.hpp:1539
pcl::Narf36::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1540
pcl::Narf36::Narf36
constexpr Narf36(float _x, float _y, float _z)
Definition point_types.hpp:1544
pcl::Narf36::x
float x
Definition point_types.hpp:1538
pcl::Narf36::Narf36
constexpr Narf36()=default
pcl::NormalBasedSignature12
A point structure representing the Normal Based Signature for a feature matrix of 4-by-3.
Definition point_types.hpp:1278
pcl::NormalBasedSignature12::values
float values[12]
Definition point_types.hpp:1279
pcl::NormalBasedSignature12::NormalBasedSignature12
constexpr NormalBasedSignature12()=default
pcl::Normal
A point structure representing normal coordinates and the surface curvature estimate.
Definition point_types.hpp:794
pcl::Normal::Normal
constexpr Normal(const _Normal &p)
Definition point_types.hpp:795
pcl::Normal::Normal
constexpr Normal(float _curvature=0.f)
Definition point_types.hpp:797
pcl::Normal::Normal
constexpr Normal(float n_x, float n_y, float n_z, float _curvature=0.f)
Definition point_types.hpp:799
pcl::PCLPointField::FLOAT32
@ FLOAT32
Definition PCLPointField.h:29
pcl::PCLPointField::UINT32
@ UINT32
Definition PCLPointField.h:26
pcl::PCLPointField::name
std::string name
Definition PCLPointField.h:14
pcl::PCLPointField::datatype
std::uint8_t datatype
Definition PCLPointField.h:17
pcl::PCLPointField::count
uindex_t count
Definition PCLPointField.h:18
pcl::PFHRGBSignature250
A point structure representing the Point Feature Histogram with colors (PFHRGB).
Definition point_types.hpp:1205
pcl::PFHRGBSignature250::histogram
float histogram[250]
Definition point_types.hpp:1206
pcl::PFHRGBSignature250::PFHRGBSignature250
constexpr PFHRGBSignature250()=default
pcl::PFHRGBSignature250::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1207
pcl::PFHSignature125
A point structure representing the Point Feature Histogram (PFH).
Definition point_types.hpp:1190
pcl::PFHSignature125::PFHSignature125
constexpr PFHSignature125()=default
pcl::PFHSignature125::histogram
float histogram[125]
Definition point_types.hpp:1191
pcl::PFHSignature125::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1192
pcl::PPFRGBSignature
A point structure for storing the Point Pair Color Feature (PPFRGB) values.
Definition point_types.hpp:1256
pcl::PPFRGBSignature::f1
float f1
Definition point_types.hpp:1257
pcl::PPFRGBSignature::PPFRGBSignature
constexpr PPFRGBSignature(float _f1, float _f2, float _f3, float _f4, float _alpha, float _r, float _g, float _b)
Definition point_types.hpp:1266
pcl::PPFRGBSignature::PPFRGBSignature
constexpr PPFRGBSignature(float _f1, float _f2, float _f3, float _f4, float _alpha=0.f)
Definition point_types.hpp:1263
pcl::PPFRGBSignature::alpha_m
float alpha_m
Definition point_types.hpp:1259
pcl::PPFRGBSignature::f4
float f4
Definition point_types.hpp:1257
pcl::PPFRGBSignature::f2
float f2
Definition point_types.hpp:1257
pcl::PPFRGBSignature::PPFRGBSignature
constexpr PPFRGBSignature(float _alpha=0.f)
Definition point_types.hpp:1261
pcl::PPFRGBSignature::g_ratio
float g_ratio
Definition point_types.hpp:1258
pcl::PPFRGBSignature::b_ratio
float b_ratio
Definition point_types.hpp:1258
pcl::PPFRGBSignature::f3
float f3
Definition point_types.hpp:1257
pcl::PPFRGBSignature::r_ratio
float r_ratio
Definition point_types.hpp:1258
pcl::PPFSignature
A point structure for storing the Point Pair Feature (PPF) values.
Definition point_types.hpp:1219
pcl::PPFSignature::f2
float f2
Definition point_types.hpp:1220
pcl::PPFSignature::f4
float f4
Definition point_types.hpp:1220
pcl::PPFSignature::alpha_m
float alpha_m
Definition point_types.hpp:1221
pcl::PPFSignature::PPFSignature
constexpr PPFSignature(float _f1, float _f2, float _f3, float _f4, float _alpha=0.f)
Definition point_types.hpp:1225
pcl::PPFSignature::f1
float f1
Definition point_types.hpp:1220
pcl::PPFSignature::PPFSignature
constexpr PPFSignature(float _alpha=0.f)
Definition point_types.hpp:1223
pcl::PPFSignature::f3
float f3
Definition point_types.hpp:1220
pcl::PointDEM
A point structure representing Digital Elevation Map.
Definition point_types.hpp:1702
pcl::PointDEM::PointDEM
constexpr PointDEM(const _PointDEM &p)
Definition point_types.hpp:1703
pcl::PointDEM::PointDEM
constexpr PointDEM(float _x, float _y, float _z, float _intensity, float _intensity_variance, float _height_variance)
Definition point_types.hpp:1710
pcl::PointDEM::PointDEM
constexpr PointDEM(float _x, float _y, float _z)
Definition point_types.hpp:1708
pcl::PointDEM::PointDEM
constexpr PointDEM()
Definition point_types.hpp:1706
pcl::PointNormal
A point structure representing Euclidean xyz coordinates, together with normal coordinates and the su...
Definition point_types.hpp:850
pcl::PointNormal::PointNormal
constexpr PointNormal(float _curvature=0.f)
Definition point_types.hpp:853
pcl::PointNormal::PointNormal
constexpr PointNormal(float _x, float _y, float _z)
Definition point_types.hpp:855
pcl::PointNormal::PointNormal
constexpr PointNormal(const _PointNormal &p)
Definition point_types.hpp:851
pcl::PointNormal::PointNormal
constexpr PointNormal(float _x, float _y, float _z, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition point_types.hpp:858
pcl::PointSurfel
A surfel, that is, a point structure representing Euclidean xyz coordinates, together with normal coo...
Definition point_types.hpp:1668
pcl::PointSurfel::PointSurfel
constexpr PointSurfel(const _PointSurfel &p)
Definition point_types.hpp:1669
pcl::PointSurfel::PointSurfel
constexpr PointSurfel()
Definition point_types.hpp:1672
pcl::PointSurfel::PointSurfel
constexpr PointSurfel(float _x, float _y, float _z, float _nx, float _ny, float _nz, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a, float _radius, float _confidence, float _curvature)
Definition point_types.hpp:1675
pcl::PointUV
A 2D point structure representing pixel image coordinates.
Definition point_types.hpp:743
pcl::PointUV::u
float u
Definition point_types.hpp:744
pcl::PointUV::PointUV
constexpr PointUV(float _u, float _v)
Definition point_types.hpp:749
pcl::PointUV::v
float v
Definition point_types.hpp:745
pcl::PointUV::PointUV
constexpr PointUV()=default
pcl::PointWithRange
A point structure representing Euclidean xyz coordinates, padded with an extra range float.
Definition point_types.hpp:1058
pcl::PointWithRange::PointWithRange
constexpr PointWithRange(float _range=0.f)
Definition point_types.hpp:1061
pcl::PointWithRange::PointWithRange
constexpr PointWithRange(float _x, float _y, float _z, float _range=0.f)
Definition point_types.hpp:1063
pcl::PointWithRange::PointWithRange
constexpr PointWithRange(const _PointWithRange &p)
Definition point_types.hpp:1059
pcl::PointWithScale
A point structure representing a 3-D position and scale.
Definition point_types.hpp:1630
pcl::PointWithScale::PointWithScale
constexpr PointWithScale()
Definition point_types.hpp:1634
pcl::PointWithScale::PointWithScale
constexpr PointWithScale(const _PointWithScale &p)
Definition point_types.hpp:1631
pcl::PointWithScale::PointWithScale
constexpr PointWithScale(float _x, float _y, float _z, float _scale=1.f, float _angle=-1.f, float _response=0.f, int _octave=0)
Definition point_types.hpp:1636
pcl::PointWithViewpoint
A point structure representing Euclidean xyz coordinates together with the viewpoint from which it wa...
Definition point_types.hpp:1091
pcl::PointWithViewpoint::PointWithViewpoint
constexpr PointWithViewpoint(float _x, float _y, float _z)
Definition point_types.hpp:1096
pcl::PointWithViewpoint::PointWithViewpoint
constexpr PointWithViewpoint(float _x, float _y, float _z, float _vp_x, float _vp_y, float _vp_z)
Definition point_types.hpp:1098
pcl::PointWithViewpoint::PointWithViewpoint
constexpr PointWithViewpoint(const _PointWithViewpoint &p)
Definition point_types.hpp:1092
pcl::PointWithViewpoint::PointWithViewpoint
constexpr PointWithViewpoint()
Definition point_types.hpp:1094
pcl::PointXY
A 2D point structure representing Euclidean xy coordinates.
Definition point_types.hpp:716
pcl::PointXY::y
float y
Definition point_types.hpp:723
pcl::PointXY::PointXY
constexpr PointXY()
Definition point_types.hpp:728
pcl::PointXY::getVector2fMap
pcl::Vector2fMap getVector2fMap()
Definition point_types.hpp:730
pcl::PointXY::PointXY
constexpr PointXY(float _x, float _y)
Definition point_types.hpp:727
pcl::PointXY::x
float x
Definition point_types.hpp:722
pcl::PointXY::getVector2fMap
pcl::Vector2fMapConst getVector2fMap() const
Definition point_types.hpp:731
pcl::PointXY::data
float data[2]
Definition point_types.hpp:719
pcl::PointXYZHSV
Definition point_types.hpp:691
pcl::PointXYZHSV::PointXYZHSV
constexpr PointXYZHSV()
Definition point_types.hpp:695
pcl::PointXYZHSV::PointXYZHSV
constexpr PointXYZHSV(const _PointXYZHSV &p)
Definition point_types.hpp:692
pcl::PointXYZHSV::PointXYZHSV
constexpr PointXYZHSV(float _h, float _s, float _v)
Definition point_types.hpp:699
pcl::PointXYZHSV::PointXYZHSV
constexpr PointXYZHSV(float _x, float _y, float _z, float _h, float _s, float _v)
Definition point_types.hpp:702
pcl::PointXYZ
A point structure representing Euclidean xyz coordinates.
Definition point_types.hpp:322
pcl::PointXYZ::PointXYZ
constexpr PointXYZ(float _x, float _y, float _z)
Definition point_types.hpp:327
pcl::PointXYZ::PointXYZ
constexpr PointXYZ(const _PointXYZ &p)
Definition point_types.hpp:323
pcl::PointXYZ::PointXYZ
constexpr PointXYZ()
Definition point_types.hpp:325
pcl::PointXYZI
Definition point_types.hpp:457
pcl::PointXYZI::PointXYZI
constexpr PointXYZI(float _x, float _y, float _z, float _intensity=0.f)
Definition point_types.hpp:462
pcl::PointXYZI::PointXYZI
constexpr PointXYZI(float _intensity=0.f)
Definition point_types.hpp:460
pcl::PointXYZI::PointXYZI
constexpr PointXYZI(const _PointXYZI &p)
Definition point_types.hpp:458
pcl::PointXYZINormal
A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates...
Definition point_types.hpp:972
pcl::PointXYZINormal::PointXYZINormal
constexpr PointXYZINormal(float _intensity=0.f)
Definition point_types.hpp:976
pcl::PointXYZINormal::PointXYZINormal
constexpr PointXYZINormal(const _PointXYZINormal &p)
Definition point_types.hpp:973
pcl::PointXYZINormal::PointXYZINormal
constexpr PointXYZINormal(float _x, float _y, float _z, float _intensity, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition point_types.hpp:981
pcl::PointXYZINormal::PointXYZINormal
constexpr PointXYZINormal(float _x, float _y, float _z, float _intensity=0.f)
Definition point_types.hpp:978
pcl::PointXYZLAB
A point structure representing Euclidean xyz coordinates, and the CIELAB color.
Definition point_types.hpp:659
pcl::PointXYZLAB::PointXYZLAB
constexpr PointXYZLAB()
Definition point_types.hpp:662
pcl::PointXYZLAB::PointXYZLAB
constexpr PointXYZLAB(float _x, float _y, float _z, float _l, float _a, float _b)
Definition point_types.hpp:664
pcl::PointXYZLAB::PointXYZLAB
constexpr PointXYZLAB(const _PointXYZLAB &p)
Definition point_types.hpp:660
pcl::PointXYZL
Definition point_types.hpp:477
pcl::PointXYZL::PointXYZL
constexpr PointXYZL(std::uint32_t _label=0)
Definition point_types.hpp:480
pcl::PointXYZL::PointXYZL
constexpr PointXYZL(const _PointXYZL &p)
Definition point_types.hpp:478
pcl::PointXYZL::PointXYZL
constexpr PointXYZL(float _x, float _y, float _z, std::uint32_t _label=0)
Definition point_types.hpp:482
pcl::PointXYZLNormal
A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates a...
Definition point_types.hpp:1015
pcl::PointXYZLNormal::PointXYZLNormal
constexpr PointXYZLNormal(const _PointXYZLNormal &p)
Definition point_types.hpp:1016
pcl::PointXYZLNormal::PointXYZLNormal
constexpr PointXYZLNormal(float _x, float _y, float _z, std::uint32_t _label=0u)
Definition point_types.hpp:1021
pcl::PointXYZLNormal::PointXYZLNormal
constexpr PointXYZLNormal(std::uint32_t _label=0u)
Definition point_types.hpp:1019
pcl::PointXYZLNormal::PointXYZLNormal
constexpr PointXYZLNormal(float _x, float _y, float _z, std::uint32_t _label, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition point_types.hpp:1024
pcl::PointXYZRGBA
A point structure representing Euclidean xyz coordinates, and the RGBA color.
Definition point_types.hpp:528
pcl::PointXYZRGBA::PointXYZRGBA
constexpr PointXYZRGBA(const _PointXYZRGBA &p)
Definition point_types.hpp:529
pcl::PointXYZRGBA::PointXYZRGBA
constexpr PointXYZRGBA()
Definition point_types.hpp:531
pcl::PointXYZRGBA::PointXYZRGBA
constexpr PointXYZRGBA(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
Definition point_types.hpp:539
pcl::PointXYZRGBA::PointXYZRGBA
constexpr PointXYZRGBA(float _x, float _y, float _z)
Definition point_types.hpp:536
pcl::PointXYZRGBA::PointXYZRGBA
constexpr PointXYZRGBA(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
Definition point_types.hpp:533
pcl::PointXYZRGB
A point structure representing Euclidean xyz coordinates, and the RGB color.
Definition point_types.hpp:594
pcl::PointXYZRGB::PointXYZRGB
constexpr PointXYZRGB(float _x, float _y, float _z)
Definition point_types.hpp:602
pcl::PointXYZRGB::PointXYZRGB
constexpr PointXYZRGB()
Definition point_types.hpp:597
pcl::PointXYZRGB::PointXYZRGB
constexpr PointXYZRGB(const _PointXYZRGB &p)
Definition point_types.hpp:595
pcl::PointXYZRGB::PointXYZRGB
constexpr PointXYZRGB(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition point_types.hpp:605
pcl::PointXYZRGB::PointXYZRGB
constexpr PointXYZRGB(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition point_types.hpp:599
pcl::PointXYZRGBL
Definition point_types.hpp:616
pcl::PointXYZRGBL::PointXYZRGBL
constexpr PointXYZRGBL(std::uint32_t _label=0)
Definition point_types.hpp:619
pcl::PointXYZRGBL::PointXYZRGBL
constexpr PointXYZRGBL(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint32_t _label=0, std::uint8_t _a=255)
Definition point_types.hpp:628
pcl::PointXYZRGBL::PointXYZRGBL
constexpr PointXYZRGBL(float _x, float _y, float _z)
Definition point_types.hpp:625
pcl::PointXYZRGBL::PointXYZRGBL
constexpr PointXYZRGBL(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition point_types.hpp:622
pcl::PointXYZRGBL::PointXYZRGBL
constexpr PointXYZRGBL(const _PointXYZRGBL &p)
Definition point_types.hpp:617
pcl::PointXYZRGBNormal
A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coo...
Definition point_types.hpp:913
pcl::PointXYZRGBNormal::PointXYZRGBNormal
constexpr PointXYZRGBNormal(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition point_types.hpp:929
pcl::PointXYZRGBNormal::PointXYZRGBNormal
constexpr PointXYZRGBNormal(float _x, float _y, float _z)
Definition point_types.hpp:920
pcl::PointXYZRGBNormal::PointXYZRGBNormal
constexpr PointXYZRGBNormal(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition point_types.hpp:923
pcl::PointXYZRGBNormal::PointXYZRGBNormal
constexpr PointXYZRGBNormal(float _curvature=0.f)
Definition point_types.hpp:917
pcl::PointXYZRGBNormal::PointXYZRGBNormal
constexpr PointXYZRGBNormal(const _PointXYZRGBNormal &p)
Definition point_types.hpp:914
pcl::PointXYZRGBNormal::PointXYZRGBNormal
constexpr PointXYZRGBNormal(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition point_types.hpp:938
pcl::PointXYZRGBNormal::PointXYZRGBNormal
constexpr PointXYZRGBNormal(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition point_types.hpp:926
pcl::PrincipalCurvatures
A point structure representing the principal curvatures and their magnitudes.
Definition point_types.hpp:1159
pcl::PrincipalCurvatures::PrincipalCurvatures
constexpr PrincipalCurvatures(float _pc1, float _pc2)
Definition point_types.hpp:1175
pcl::PrincipalCurvatures::pc2
float pc2
Definition point_types.hpp:1171
pcl::PrincipalCurvatures::PrincipalCurvatures
constexpr PrincipalCurvatures()
Definition point_types.hpp:1173
pcl::PrincipalCurvatures::principal_curvature_x
float principal_curvature_x
Definition point_types.hpp:1165
pcl::PrincipalCurvatures::PrincipalCurvatures
constexpr PrincipalCurvatures(float _x, float _y, float _z)
Definition point_types.hpp:1177
pcl::PrincipalCurvatures::pc1
float pc1
Definition point_types.hpp:1170
pcl::PrincipalCurvatures::principal_curvature_z
float principal_curvature_z
Definition point_types.hpp:1167
pcl::PrincipalCurvatures::principal_curvature_y
float principal_curvature_y
Definition point_types.hpp:1166
pcl::PrincipalCurvatures::PrincipalCurvatures
constexpr PrincipalCurvatures(float _x, float _y, float _z, float _pc1, float _pc2)
Definition point_types.hpp:1179
pcl::PrincipalCurvatures::principal_curvature
float principal_curvature[3]
Definition point_types.hpp:1162
pcl::PrincipalRadiiRSD
A point structure representing the minimum and maximum surface radii (in meters) computed using RSD.
Definition point_types.hpp:1124
pcl::PrincipalRadiiRSD::r_min
float r_min
Definition point_types.hpp:1125
pcl::PrincipalRadiiRSD::r_max
float r_max
Definition point_types.hpp:1125
pcl::PrincipalRadiiRSD::PrincipalRadiiRSD
constexpr PrincipalRadiiRSD(float _r_min, float _r_max)
Definition point_types.hpp:1129
pcl::PrincipalRadiiRSD::PrincipalRadiiRSD
constexpr PrincipalRadiiRSD()=default
pcl::RGB
A structure representing RGB color information.
Definition point_types.hpp:363
pcl::RGB::RGB
constexpr RGB(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a=255)
Definition point_types.hpp:368
pcl::RGB::RGB
constexpr RGB()
Definition point_types.hpp:366
pcl::RGB::RGB
constexpr RGB(const _RGB &p)
Definition point_types.hpp:364
pcl::ReferenceFrame
Definition point_types.hpp:1378
pcl::ReferenceFrame::ReferenceFrame
constexpr ReferenceFrame()
Definition point_types.hpp:1385
pcl::ReferenceFrame::ReferenceFrame
constexpr ReferenceFrame(const float(&_rf)[9])
Definition point_types.hpp:1394
pcl::ReferenceFrame::ReferenceFrame
constexpr ReferenceFrame(const _ReferenceFrame &p)
Definition point_types.hpp:1379
pcl::SHOT1344
A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+col...
Definition point_types.hpp:1337
pcl::SHOT1344::descriptor
float descriptor[1344]
Definition point_types.hpp:1338
pcl::SHOT1344::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1340
pcl::SHOT1344::SHOT1344
constexpr SHOT1344()=default
pcl::SHOT1344::rf
float rf[9]
Definition point_types.hpp:1339
pcl::SHOT352
A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape onl...
Definition point_types.hpp:1321
pcl::SHOT352::descriptor
float descriptor[352]
Definition point_types.hpp:1322
pcl::SHOT352::SHOT352
constexpr SHOT352()=default
pcl::SHOT352::rf
float rf[9]
Definition point_types.hpp:1323
pcl::SHOT352::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1324
pcl::ShapeContext1980
A point structure representing a Shape Context.
Definition point_types.hpp:1291
pcl::ShapeContext1980::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1294
pcl::ShapeContext1980::ShapeContext1980
constexpr ShapeContext1980()=default
pcl::ShapeContext1980::descriptor
float descriptor[1980]
Definition point_types.hpp:1292
pcl::ShapeContext1980::rf
float rf[9]
Definition point_types.hpp:1293
pcl::UniqueShapeContext1960
A point structure representing a Unique Shape Context.
Definition point_types.hpp:1306
pcl::UniqueShapeContext1960::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1309
pcl::UniqueShapeContext1960::descriptor
float descriptor[1960]
Definition point_types.hpp:1307
pcl::UniqueShapeContext1960::rf
float rf[9]
Definition point_types.hpp:1308
pcl::UniqueShapeContext1960::UniqueShapeContext1960
constexpr UniqueShapeContext1960()=default
pcl::VFHSignature308
A point structure representing the Viewpoint Feature Histogram (VFH).
Definition point_types.hpp:1421
pcl::VFHSignature308::histogram
float histogram[308]
Definition point_types.hpp:1422
pcl::VFHSignature308::descriptorSize
static constexpr int descriptorSize()
Definition point_types.hpp:1423
pcl::VFHSignature308::VFHSignature308
constexpr VFHSignature308()=default
pcl::detail::traits::descriptorSize< BRISKSignature512 >::value
static constexpr const int value
Definition point_types.hpp:178
pcl::detail::traits::descriptorSize< ESFSignature640 >::value
static constexpr const int value
Definition point_types.hpp:179
pcl::detail::traits::descriptorSize< FPFHSignature33 >::value
static constexpr const int value
Definition point_types.hpp:175
pcl::detail::traits::descriptorSize< GASDSignature512 >::value
static constexpr const int value
Definition point_types.hpp:180
pcl::detail::traits::descriptorSize< GASDSignature7992 >::value
static constexpr const int value
Definition point_types.hpp:182
pcl::detail::traits::descriptorSize< GASDSignature984 >::value
static constexpr const int value
Definition point_types.hpp:181
pcl::detail::traits::descriptorSize< GFPFHSignature16 >::value
static constexpr const int value
Definition point_types.hpp:183
pcl::detail::traits::descriptorSize< GRSDSignature21 >::value
static constexpr const int value
Definition point_types.hpp:177
pcl::detail::traits::descriptorSize< Histogram< N > >::value
static constexpr const int value
Definition point_types.hpp:185
pcl::detail::traits::descriptorSize< Narf36 >::value
static constexpr const int value
Definition point_types.hpp:184
pcl::detail::traits::descriptorSize< PFHRGBSignature250 >::value
static constexpr const int value
Definition point_types.hpp:170
pcl::detail::traits::descriptorSize< PFHSignature125 >::value
static constexpr const int value
Definition point_types.hpp:169
pcl::detail::traits::descriptorSize< SHOT1344 >::value
static constexpr const int value
Definition point_types.hpp:174
pcl::detail::traits::descriptorSize< SHOT352 >::value
static constexpr const int value
Definition point_types.hpp:173
pcl::detail::traits::descriptorSize< ShapeContext1980 >::value
static constexpr const int value
Definition point_types.hpp:171
pcl::detail::traits::descriptorSize< UniqueShapeContext1960 >::value
static constexpr const int value
Definition point_types.hpp:172
pcl::detail::traits::descriptorSize< VFHSignature308 >::value
static constexpr const int value
Definition point_types.hpp:176
pcl::detail::traits::descriptorSize
Definition point_types.hpp:167