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_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 that include XYZ data
#define PCL_XYZ_POINT_TYPES \
(pcl::PointXYZ) \
(pcl::PointXYZI) \
(pcl::PointXYZL) \
(pcl::PointXYZRGBA) \
(pcl::PointXYZRGB) \
(pcl::PointXYZRGBL) \
(pcl::PointXYZLAB) \
(pcl::PointXYZHSV) \
(pcl::InterestPoint) \
(pcl::PointNormal) \
(pcl::PointXYZRGBNormal) \
(pcl::PointXYZINormal) \
(pcl::PointXYZLNormal) \
(pcl::PointWithRange) \
(pcl::PointWithViewpoint) \
(pcl::PointWithScale) \
(pcl::PointSurfel) \
(pcl::PointDEM)
// Define all point types with XYZ and label
#define PCL_XYZL_POINT_TYPES \
(pcl::PointXYZL) \
(pcl::PointXYZRGBL) \
(pcl::PointXYZLNormal)
// Define all point types that include normal[3] data
#define PCL_NORMAL_POINT_TYPES \
(pcl::Normal) \
(pcl::PointNormal) \
(pcl::PointXYZRGBNormal) \
(pcl::PointXYZINormal) \
(pcl::PointXYZLNormal) \
(pcl::PointSurfel)
// 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 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::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 PointXYZ (const _PointXYZ &p): PointXYZ(p.x, p.y, p.z) {}
inline PointXYZ (): PointXYZ(0.f, 0.f, 0.f) {}
inline PointXYZ (float _x, float _y, float _z)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
}
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 RGB (const _RGB &p)
{
rgba = p.rgba;
}
inline RGB (): RGB(0, 0, 0) {}
inline RGB (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
{
r = _r; g = _g; b = _b;
a = 255;
}
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 Intensity (const _Intensity &p)
{
intensity = p.intensity;
}
inline 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 Intensity8u (const _Intensity8u &p)
{
intensity = p.intensity;
}
inline Intensity8u (std::uint8_t _intensity = 0)
{
intensity = _intensity;
}
#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 1101
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 Intensity32u (const _Intensity32u &p)
{
intensity = p.intensity;
}
inline Intensity32u (std::uint32_t _intensity = 0)
{
intensity = _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 PointXYZI (const _PointXYZI &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
intensity = p.intensity;
}
inline PointXYZI (float _intensity = 0.f): PointXYZI(0.f, 0.f, 0.f, _intensity) {}
inline PointXYZI (float _x, float _y, float _z, float _intensity = 0.f)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
intensity = _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 PointXYZL (const _PointXYZL &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
label = p.label;
}
inline PointXYZL (std::uint32_t _label = 0): PointXYZL(0.f, 0.f, 0.f, _label) {}
inline PointXYZL (float _x, float _y, float _z, std::uint32_t _label = 0)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
label = _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;
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 PointXYZRGBA (const _PointXYZRGBA &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
rgba = p.rgba;
}
inline PointXYZRGBA (): PointXYZRGBA (0, 0, 0, 255) {}
inline 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 PointXYZRGBA (float _x, float _y, float _z):
PointXYZRGBA (_x, _y, _z, 0, 0, 0, 255) {}
inline PointXYZRGBA (float _x, float _y, float _z, std::uint8_t _r,
std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
r = _r; g = _g; b = _b; a = _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 PointXYZRGB (const _PointXYZRGB &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
rgb = p.rgb;
}
inline PointXYZRGB (): PointXYZRGB (0.f, 0.f, 0.f) {}
inline PointXYZRGB (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
PointXYZRGB (0.f, 0.f, 0.f, _r, _g, _b) {}
inline PointXYZRGB (float _x, float _y, float _z):
PointXYZRGB (_x, _y, _z, 0, 0, 0) {}
inline PointXYZRGB (float _x, float _y, float _z,
std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
r = _r; g = _g; b = _b;
a = 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 PointXYZRGBL (const _PointXYZRGBL &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
rgba = p.rgba;
label = p.label;
}
inline PointXYZRGBL (std::uint32_t _label = 0):
PointXYZRGBL (0.f, 0.f, 0.f, 0, 0, 0, _label) {}
inline PointXYZRGBL (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
PointXYZRGBL (0.f, 0.f, 0.f, _r, _g, _b) {}
inline PointXYZRGBL (float _x, float _y, float _z):
PointXYZRGBL (_x, _y, _z, 0, 0, 0) {}
inline PointXYZRGBL (float _x, float _y, float _z,
std::uint8_t _r, std::uint8_t _g, std::uint8_t _b,
std::uint32_t _label = 0)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
r = _r; g = _g; b = _b;
a = 255;
label = _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 PointXYZLAB (const _PointXYZLAB &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
L = p.L; a = p.a; b = p.b;
}
inline PointXYZLAB()
{
x = y = z = 0.0f;
data[3] = 1.0f; // important for homogeneous coordinates
L = a = b = 0.0f;
data_lab[3] = 0.0f;
}
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 PointXYZHSV (const _PointXYZHSV &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
h = p.h; s = p.s; v = p.v;
}
inline PointXYZHSV (): PointXYZHSV (0.f, 0.f, 0.f) {}
// @TODO: Use strong types??
// This is a dangerous type, doesn't behave like others
inline PointXYZHSV (float _h, float _s, float _v):
PointXYZHSV (0.f, 0.f, 0.f, _h, _s, _v) {}
inline PointXYZHSV (float _x, float _y, float _z,
float _h, float _s, float _v)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
h = _h; s = _s; v = _v;
data_c[3] = 0;
}
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
*/
struct PointXY
{
float x = 0.f;
float y = 0.f;
inline PointXY() = default;
inline PointXY(float _x, float _y): x(_x), y(_y) {}
friend std::ostream& operator << (std::ostream& os, const PointXY& p);
};
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 PointUV() = default;
inline 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 Normal (const _Normal &p)
{
normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z;
data_n[3] = 0.0f;
curvature = p.curvature;
}
inline Normal (float _curvature = 0.f): Normal (0.f, 0.f, 0.f, _curvature) {}
inline Normal (float n_x, float n_y, float n_z, float _curvature = 0.f)
{
normal_x = n_x; normal_y = n_y; normal_z = n_z;
data_n[3] = 0.0f;
curvature = _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 Axis (const _Axis &p)
{
normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z;
data_n[3] = 0.0f;
}
inline Axis (): Axis (0.f, 0.f, 0.f) {}
inline Axis (float n_x, float n_y, float n_z)
{
normal_x = n_x; normal_y = n_y; normal_z = n_z;
data_n[3] = 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 PointNormal (const _PointNormal &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z; data_n[3] = 0.0f;
curvature = p.curvature;
}
inline PointNormal (float _curvature = 0.f): PointNormal (0.f, 0.f, 0.f, 0.f, 0.f, 0.f, _curvature) {}
inline PointNormal (float _x, float _y, float _z):
PointNormal (_x, _y, _z, 0.f, 0.f, 0.f, 0.f) {}
inline PointNormal (float _x, float _y, float _z, float n_x, float n_y, float n_z, float _curvature = 0.f)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
normal_x = n_x; normal_y = n_y; normal_z = n_z;
data_n[3] = 0.0f;
curvature = _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 PointXYZRGBNormal (const _PointXYZRGBNormal &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z; data_n[3] = 0.0f;
curvature = p.curvature;
rgba = p.rgba;
}
inline PointXYZRGBNormal (float _curvature = 0.f):
PointXYZRGBNormal (0.f, 0.f, 0.f, 0, 0, 0, 0.f, 0.f, 0.f, _curvature) {}
inline PointXYZRGBNormal (float _x, float _y, float _z):
PointXYZRGBNormal (_x, _y, _z, 0, 0, 0) {}
inline PointXYZRGBNormal (std::uint8_t _r, std::uint8_t _g, std::uint8_t _b):
PointXYZRGBNormal (0.f, 0.f, 0.f, _r, _g, _b) {}
inline 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 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)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
r = _r; g = _g; b = _b;
a = 255;
normal_x = n_x; normal_y = n_y; normal_z = n_z;
data_n[3] = 0.f;
curvature = _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 PointXYZINormal (const _PointXYZINormal &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z; data_n[3] = 0.0f;
curvature = p.curvature;
intensity = p.intensity;
}
inline PointXYZINormal (float _intensity = 0.f): PointXYZINormal (0.f, 0.f, 0.f, _intensity) {}
inline PointXYZINormal (float _x, float _y, float _z, float _intensity = 0.f):
PointXYZINormal (_x, _y, _z, _intensity, 0.f, 0.f, 0.f) {}
inline PointXYZINormal (float _x, float _y, float _z, float _intensity,
float n_x, float n_y, float n_z, float _curvature = 0.f)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
intensity = _intensity;
normal_x = n_x; normal_y = n_y; normal_z = n_z;
data_n[3] = 0.f;
curvature = _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 PointXYZLNormal (const _PointXYZLNormal &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
normal_x = p.normal_x; normal_y = p.normal_y; normal_z = p.normal_z; data_n[3] = 0.0f;
curvature = p.curvature;
label = p.label;
}
inline PointXYZLNormal (std::uint32_t _label = 0): PointXYZLNormal (0.f, 0.f, 0.f, _label) {}
inline PointXYZLNormal (float _x, float _y, float _z, std::uint32_t _label = 0.f):
PointXYZLNormal (_x, _y, _z, _label, 0.f, 0.f, 0.f) {}
inline PointXYZLNormal (float _x, float _y, float _z, std::uint32_t _label,
float n_x, float n_y, float n_z, float _curvature = 0.f)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
label = _label;
normal_x = n_x; normal_y = n_y; normal_z = n_z;
data_n[3] = 0.f;
curvature = _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 PointWithRange (const _PointWithRange &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
range = p.range;
}
inline PointWithRange (float _range = 0.f): PointWithRange (0.f, 0.f, 0.f, _range) {}
inline PointWithRange (float _x, float _y, float _z, float _range = 0.f)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
range = _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 PointWithViewpoint (const _PointWithViewpoint &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
vp_x = p.vp_x; vp_y = p.vp_y; vp_z = p.vp_z;
}
inline PointWithViewpoint (): PointWithViewpoint (0.f, 0.f, 0.f) {}
inline PointWithViewpoint (float _x, float _y, float _z): PointWithViewpoint (_x, _y, _z, 0.f, 0.f, 0.f) {}
inline PointWithViewpoint (float _x, float _y, float _z, float _vp_x, float _vp_y, float _vp_z)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
vp_x = _vp_x; vp_y = _vp_y; vp_z = _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 MomentInvariants () = default;
inline 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 PrincipalRadiiRSD () = default;
inline 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
operator unsigned char() const
{
return boundary_point;
}
#endif
inline 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 PrincipalCurvatures (): PrincipalCurvatures (0.f, 0.f) {}
inline PrincipalCurvatures (float _pc1, float _pc2): PrincipalCurvatures (0.f, 0.f, 0.f, _pc1, _pc2) {}
inline PrincipalCurvatures (float _x, float _y, float _z): PrincipalCurvatures (_x, _y, _z, 0.f, 0.f) {}
inline 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 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 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 PPFSignature (float _alpha = 0.f): PPFSignature (0.f, 0.f, 0.f, 0.f, _alpha) {}
inline 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 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 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 PPFRGBSignature (float _alpha = 0.f): PPFRGBSignature (0.f, 0.f, 0.f, 0.f, _alpha) {}
inline 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 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 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 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 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 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 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 ReferenceFrame (const _ReferenceFrame &p)
{
std::copy_n(p.rf, 9, rf);
}
inline ReferenceFrame ()
{
std::fill_n(x_axis, 3, 0.f);
std::fill_n(y_axis, 3, 0.f);
std::fill_n(z_axis, 3, 0.f);
}
// @TODO: add other ctors
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 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 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 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 BRISKSignature512 () = default;
inline 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 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 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 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 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 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 Narf36 () = default;
inline Narf36 (float _x, float _y, float _z): Narf36 (_x, _y, _z, 0.f, 0.f, 0.f) {}
inline 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 BorderDescription () = default;
// TODO: provide other ctors
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 IntensityGradient (): IntensityGradient (0.f, 0.f, 0.f) {}
inline 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 PointWithScale (const _PointWithScale &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
scale = p.scale;
angle = p.angle;
response = p.response;
octave = p.octave;
}
inline PointWithScale (): PointWithScale (0.f, 0.f, 0.f) {}
inline PointWithScale (float _x, float _y, float _z, float _scale = 1.f,
float _angle = -1.f, float _response = 0.f, int _octave = 0)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
scale = _scale;
angle = _angle;
response = _response;
octave = _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 PointSurfel (const _PointSurfel &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
rgba = p.rgba;
radius = p.radius;
confidence = p.confidence;
curvature = p.curvature;
}
inline PointSurfel ()
{
x = y = z = 0.0f;
data[3] = 1.0f;
normal_x = normal_y = normal_z = data_n[3] = 0.0f;
r = g = b = 0;
a = 255;
radius = confidence = curvature = 0.0f;
}
// TODO: add other ctor to PointSurfel
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 PointDEM (const _PointDEM &p)
{
x = p.x; y = p.y; z = p.z; data[3] = 1.0f;
intensity = p.intensity;
intensity_variance = p.intensity_variance;
height_variance = p.height_variance;
}
inline PointDEM (): PointDEM (0.f, 0.f, 0.f) {}
inline PointDEM (float _x, float _y, float _z): PointDEM (_x, _y, _z, 0.f, 0.f, 0.f) {}
inline PointDEM (float _x, float _y, float _z, float _intensity,
float _intensity_variance, float _height_variance)
{
x = _x; y = _y; z = _z;
data[3] = 1.0f;
intensity = _intensity;
intensity_variance = _intensity_variance;
height_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, rgb, rgb)
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(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, intensity, intensity)
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(float, curvature, curvature)
)
POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::PointXYZLNormal,
(float, x, x)
(float, y, y)
(float, z, z)
(std::uint32_t, label, label)
(float, normal_x, normal_x)
(float, normal_y, normal_y)
(float, normal_z, normal_z)
(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:63
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::descriptorSize_v
static constexpr int descriptorSize_v
Definition: point_types.hpp:218
pcl
Definition: convolution.h:46
pcl::Vector4fMap
Eigen::Map< Eigen::Vector4f, Eigen::Aligned > Vector4fMap
Definition: point_types.hpp:228
pcl::Vector4cMapConst
const Eigen::Map< const Vector4c, Eigen::Aligned > Vector4cMapConst
Definition: point_types.hpp:236
pcl::Vector4cMap
Eigen::Map< Vector4c, Eigen::Aligned > Vector4cMap
Definition: point_types.hpp:235
pcl::operator<<
std::ostream & operator<<(std::ostream &os, const BivariatePolynomialT< real > &p)
Definition: bivariate_polynomial.hpp:240
pcl::Vector3fMapConst
const Eigen::Map< const Eigen::Vector3f > Vector3fMapConst
Definition: point_types.hpp:227
pcl::Vector3cMapConst
const Eigen::Map< const Vector3c > Vector3cMapConst
Definition: point_types.hpp:233
pcl::Vector3fMap
Eigen::Map< Eigen::Vector3f > Vector3fMap
Definition: point_types.hpp:226
pcl::Vector4c
Eigen::Matrix< std::uint8_t, 4, 1 > Vector4c
Definition: point_types.hpp:234
pcl::Vector4fMapConst
const Eigen::Map< const Eigen::Vector4f, Eigen::Aligned > Vector4fMapConst
Definition: point_types.hpp:229
pcl::Array4fMapConst
const Eigen::Map< const Eigen::Array4f, Eigen::Aligned > Array4fMapConst
Definition: point_types.hpp:225
pcl::Vector3c
Eigen::Matrix< std::uint8_t, 3, 1 > Vector3c
Definition: point_types.hpp:231
pcl::Array4fMap
Eigen::Map< Eigen::Array4f, Eigen::Aligned > Array4fMap
Definition: point_types.hpp:224
pcl::Array3fMapConst
const Eigen::Map< const Eigen::Array3f > Array3fMapConst
Definition: point_types.hpp:223
pcl::Vector3cMap
Eigen::Map< Vector3c > Vector3cMap
Definition: point_types.hpp:232
pcl::Array3fMap
Eigen::Map< Eigen::Array3f > Array3fMap
Definition: point_types.hpp:222
pcl_macros.h
Defines all the PCL and non-PCL macros used.
PCL_EXPORTS
#define PCL_EXPORTS
Definition: pcl_macros.h:323
PCL_IF_CONSTEXPR
#define PCL_IF_CONSTEXPR(x)
Definition: pcl_macros.h:449
pcl::_Axis
Definition: point_types.hpp:923
pcl::_Axis::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:924
pcl::_Intensity32u
Definition: point_types.hpp:468
pcl::_Intensity32u::PCL_ADD_INTENSITY_32U
PCL_ADD_INTENSITY_32U
Definition: point_types.hpp:469
pcl::_Intensity8u
Definition: point_types.hpp:436
pcl::_Intensity8u::PCL_ADD_INTENSITY_8U
PCL_ADD_INTENSITY_8U
Definition: point_types.hpp:437
pcl::_Intensity
Definition: point_types.hpp:410
pcl::_Intensity::PCL_ADD_INTENSITY
PCL_ADD_INTENSITY
Definition: point_types.hpp:411
pcl::_Normal
Definition: point_types.hpp:882
pcl::_Normal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:883
pcl::_Normal::curvature
float curvature
Definition: point_types.hpp:888
pcl::_PointDEM
Definition: point_types.hpp:1866
pcl::_PointDEM::intensity_variance
float intensity_variance
Definition: point_types.hpp:1869
pcl::_PointDEM::intensity
float intensity
Definition: point_types.hpp:1868
pcl::_PointDEM::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1867
pcl::_PointDEM::height_variance
float height_variance
Definition: point_types.hpp:1870
pcl::_PointNormal
Definition: point_types.hpp:954
pcl::_PointNormal::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:955
pcl::_PointNormal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:956
pcl::_PointNormal::curvature
float curvature
Definition: point_types.hpp:961
pcl::_PointSurfel
Definition: point_types.hpp:1817
pcl::_PointSurfel::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:1819
pcl::_PointSurfel::PCL_ADD_UNION_RGB
PCL_ADD_UNION_RGB
Definition: point_types.hpp:1824
pcl::_PointSurfel::curvature
float curvature
Definition: point_types.hpp:1827
pcl::_PointSurfel::PCL_ADD_EIGEN_MAPS_RGB
PCL_ADD_EIGEN_MAPS_RGB
Definition: point_types.hpp:1831
pcl::_PointSurfel::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1818
pcl::_PointSurfel::confidence
float confidence
Definition: point_types.hpp:1826
pcl::_PointSurfel::radius
float radius
Definition: point_types.hpp:1825
pcl::_PointWithRange
Definition: point_types.hpp:1186
pcl::_PointWithRange::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1187
pcl::_PointWithRange::range
float range
Definition: point_types.hpp:1192
pcl::_PointWithScale
Definition: point_types.hpp:1764
pcl::_PointWithScale::angle
float angle
Computed orientation of the keypoint (-1 if not applicable).
Definition: point_types.hpp:1775
pcl::_PointWithScale::response
float response
The response by which the most strong keypoints have been selected.
Definition: point_types.hpp:1777
pcl::_PointWithScale::octave
int octave
octave (pyramid layer) from which the keypoint has been extracted.
Definition: point_types.hpp:1779
pcl::_PointWithScale::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1765
pcl::_PointWithScale::scale
float scale
Diameter of the meaningful keypoint neighborhood.
Definition: point_types.hpp:1770
pcl::_PointWithScale::size
float size
Definition: point_types.hpp:1771
pcl::_PointWithViewpoint
Definition: point_types.hpp:1225
pcl::_PointWithViewpoint::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1226
pcl::_PointWithViewpoint::vp_z
float vp_z
Definition: point_types.hpp:1233
pcl::_PointWithViewpoint::vp_y
float vp_y
Definition: point_types.hpp:1232
pcl::_PointWithViewpoint::vp_x
float vp_x
Definition: point_types.hpp:1231
pcl::_PointXYZHSV
Definition: point_types.hpp:781
pcl::_PointXYZHSV::v
float v
Definition: point_types.hpp:789
pcl::_PointXYZHSV::h
float h
Definition: point_types.hpp:787
pcl::_PointXYZHSV::s
float s
Definition: point_types.hpp:788
pcl::_PointXYZHSV::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:782
pcl::_PointXYZ
Definition: point_types.hpp:336
pcl::_PointXYZ::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:337
pcl::_PointXYZI
A point structure representing Euclidean xyz coordinates, and the intensity value.
Definition: point_types.hpp:496
pcl::_PointXYZI::intensity
float intensity
Definition: point_types.hpp:502
pcl::_PointXYZI::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:497
pcl::_PointXYZINormal
Definition: point_types.hpp:1084
pcl::_PointXYZINormal::intensity
float intensity
Definition: point_types.hpp:1091
pcl::_PointXYZINormal::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1085
pcl::_PointXYZINormal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:1086
pcl::_PointXYZINormal::curvature
float curvature
Definition: point_types.hpp:1092
pcl::_PointXYZLAB
Definition: point_types.hpp:740
pcl::_PointXYZLAB::a
float a
Definition: point_types.hpp:747
pcl::_PointXYZLAB::b
float b
Definition: point_types.hpp:748
pcl::_PointXYZLAB::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:741
pcl::_PointXYZLAB::data_lab
float data_lab[4]
Definition: point_types.hpp:750
pcl::_PointXYZLAB::L
float L
Definition: point_types.hpp:746
pcl::_PointXYZL
Definition: point_types.hpp:532
pcl::_PointXYZL::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:533
pcl::_PointXYZL::label
std::uint32_t label
Definition: point_types.hpp:534
pcl::_PointXYZLNormal
Definition: point_types.hpp:1134
pcl::_PointXYZLNormal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:1136
pcl::_PointXYZLNormal::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1135
pcl::_PointXYZLNormal::curvature
float curvature
Definition: point_types.hpp:1142
pcl::_PointXYZLNormal::label
std::uint32_t label
Definition: point_types.hpp:1141
pcl::_PointXYZRGBA
Definition: point_types.hpp:572
pcl::_PointXYZRGBA::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:573
pcl::_PointXYZRGBA::PCL_ADD_RGB
PCL_ADD_RGB
Definition: point_types.hpp:574
pcl::_PointXYZRGB
Definition: point_types.hpp:628
pcl::_PointXYZRGB::PCL_ADD_RGB
PCL_ADD_RGB
Definition: point_types.hpp:630
pcl::_PointXYZRGB::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:629
pcl::_PointXYZRGBL
Definition: point_types.hpp:635
pcl::_PointXYZRGBL::PCL_ADD_RGB
PCL_ADD_RGB
Definition: point_types.hpp:637
pcl::_PointXYZRGBL::label
std::uint32_t label
Definition: point_types.hpp:638
pcl::_PointXYZRGBL::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:636
pcl::_PointXYZRGBNormal
Definition: point_types.hpp:1000
pcl::_PointXYZRGBNormal::PCL_ADD_NORMAL4D
PCL_ADD_NORMAL4D
Definition: point_types.hpp:1002
pcl::_PointXYZRGBNormal::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:1001
pcl::_PointXYZRGBNormal::curvature
float curvature
Definition: point_types.hpp:1008
pcl::_PointXYZRGBNormal::PCL_ADD_EIGEN_MAPS_RGB
PCL_ADD_EIGEN_MAPS_RGB
Definition: point_types.hpp:1012
pcl::_PointXYZRGBNormal::PCL_ADD_UNION_RGB
PCL_ADD_UNION_RGB
Definition: point_types.hpp:1007
pcl::_RGB
Definition: point_types.hpp:367
pcl::_RGB::PCL_ADD_RGB
PCL_ADD_RGB
Definition: point_types.hpp:368
pcl::_ReferenceFrame
A structure representing the Local Reference Frame of a point.
Definition: point_types.hpp:1514
pcl::_ReferenceFrame::getMatrix3fMap
const Eigen::Map< const Eigen::Matrix3f > getMatrix3fMap() const
Definition: point_types.hpp:1533
pcl::_ReferenceFrame::getYAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getYAxisVector3fMap() const
Definition: point_types.hpp:1529
pcl::_ReferenceFrame::getXAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getXAxisVector3fMap()
Definition: point_types.hpp:1526
pcl::_ReferenceFrame::getYAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getYAxisVector3fMap()
Definition: point_types.hpp:1528
pcl::_ReferenceFrame::getZAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getZAxisVector3fMap() const
Definition: point_types.hpp:1531
pcl::_ReferenceFrame::getZAxisVector3fMap
Eigen::Map< Eigen::Vector3f > getZAxisVector3fMap()
Definition: point_types.hpp:1530
pcl::_ReferenceFrame::getXAxisVector3fMap
const Eigen::Map< const Eigen::Vector3f > getXAxisVector3fMap() const
Definition: point_types.hpp:1527
pcl::_ReferenceFrame::getMatrix3fMap
Eigen::Map< Eigen::Matrix3f > getMatrix3fMap()
Definition: point_types.hpp:1532
pcl::_ReferenceFrame::rf
float rf[9]
Definition: point_types.hpp:1517
pcl::Axis
A point structure representing an Axis using its normal coordinates.
Definition: point_types.hpp:933
pcl::Axis::Axis
Axis()
Definition: point_types.hpp:940
pcl::Axis::Axis
Axis(const _Axis &p)
Definition: point_types.hpp:934
pcl::Axis::Axis
Axis(float n_x, float n_y, float n_z)
Definition: point_types.hpp:942
pcl::BRISKSignature512
A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK).
Definition: point_types.hpp:1607
pcl::BRISKSignature512::BRISKSignature512
BRISKSignature512()=default
pcl::BRISKSignature512::scale
float scale
Definition: point_types.hpp:1608
pcl::BRISKSignature512::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1611
pcl::BRISKSignature512::BRISKSignature512
BRISKSignature512(float _scale, float _orientation)
Definition: point_types.hpp:1615
pcl::BRISKSignature512::orientation
float orientation
Definition: point_types.hpp:1609
pcl::BRISKSignature512::operator<<
friend std::ostream & operator<<(std::ostream &os, const BRISKSignature512 &p)
pcl::BRISKSignature512::descriptor
unsigned char descriptor[64]
Definition: point_types.hpp:1610
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:1715
pcl::BorderDescription::operator<<
friend std::ostream & operator<<(std::ostream &os, const BorderDescription &p)
pcl::BorderDescription::BorderDescription
BorderDescription()=default
pcl::BorderDescription::y
int y
Definition: point_types.hpp:1716
pcl::BorderDescription::traits
BorderTraits traits
Definition: point_types.hpp:1717
pcl::BorderDescription::x
int x
Definition: point_types.hpp:1716
pcl::Boundary
A point structure representing a description of whether a point is lying on a surface boundary or not...
Definition: point_types.hpp:1301
pcl::Boundary::Boundary
Boundary(std::uint8_t _boundary=0)
Definition: point_types.hpp:1311
pcl::Boundary::boundary_point
std::uint8_t boundary_point
Definition: point_types.hpp:1302
pcl::Boundary::operator<<
friend std::ostream & operator<<(std::ostream &os, const Boundary &p)
pcl::CPPFSignature
A point structure for storing the Point Pair Feature (CPPF) values.
Definition: point_types.hpp:1398
pcl::CPPFSignature::operator<<
friend std::ostream & operator<<(std::ostream &os, const CPPFSignature &p)
pcl::CPPFSignature::f2
float f2
Definition: point_types.hpp:1399
pcl::CPPFSignature::f8
float f8
Definition: point_types.hpp:1399
pcl::CPPFSignature::f9
float f9
Definition: point_types.hpp:1399
pcl::CPPFSignature::f4
float f4
Definition: point_types.hpp:1399
pcl::CPPFSignature::CPPFSignature
CPPFSignature(float _alpha=0.f)
Definition: point_types.hpp:1402
pcl::CPPFSignature::f5
float f5
Definition: point_types.hpp:1399
pcl::CPPFSignature::f1
float f1
Definition: point_types.hpp:1399
pcl::CPPFSignature::alpha_m
float alpha_m
Definition: point_types.hpp:1400
pcl::CPPFSignature::f7
float f7
Definition: point_types.hpp:1399
pcl::CPPFSignature::f6
float f6
Definition: point_types.hpp:1399
pcl::CPPFSignature::f10
float f10
Definition: point_types.hpp:1399
pcl::CPPFSignature::f3
float f3
Definition: point_types.hpp:1399
pcl::CPPFSignature::CPPFSignature
CPPFSignature(float _f1, float _f2, float _f3, float _f4, float _f5, float _f6, float _f7, float _f8, float _f9, float _f10, float _alpha=0.f)
Definition: point_types.hpp:1405
pcl::ESFSignature640
A point structure representing the Ensemble of Shape Functions (ESF).
Definition: point_types.hpp:1625
pcl::ESFSignature640::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1627
pcl::ESFSignature640::operator<<
friend std::ostream & operator<<(std::ostream &os, const ESFSignature640 &p)
pcl::ESFSignature640::ESFSignature640
ESFSignature640()=default
pcl::ESFSignature640::histogram
float histogram[640]
Definition: point_types.hpp:1626
pcl::FPFHSignature33
A point structure representing the Fast Point Feature Histogram (FPFH).
Definition: point_types.hpp:1565
pcl::FPFHSignature33::FPFHSignature33
FPFHSignature33()=default
pcl::FPFHSignature33::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1567
pcl::FPFHSignature33::histogram
float histogram[33]
Definition: point_types.hpp:1566
pcl::FPFHSignature33::operator<<
friend std::ostream & operator<<(std::ostream &os, const FPFHSignature33 &p)
pcl::FieldMatches::operator()
bool operator()(const PCLPointField &field)
Definition: PCLPointField.h:55
pcl::GASDSignature512
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor.
Definition: point_types.hpp:1639
pcl::GASDSignature512::GASDSignature512
GASDSignature512()=default
pcl::GASDSignature512::histogram
float histogram[512]
Definition: point_types.hpp:1640
pcl::GASDSignature512::operator<<
friend std::ostream & operator<<(std::ostream &os, const GASDSignature512 &p)
pcl::GASDSignature512::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1641
pcl::GASDSignature7992
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descr...
Definition: point_types.hpp:1667
pcl::GASDSignature7992::histogram
float histogram[7992]
Definition: point_types.hpp:1668
pcl::GASDSignature7992::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1669
pcl::GASDSignature7992::GASDSignature7992
GASDSignature7992()=default
pcl::GASDSignature7992::operator<<
friend std::ostream & operator<<(std::ostream &os, const GASDSignature7992 &p)
pcl::GASDSignature984
A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descr...
Definition: point_types.hpp:1653
pcl::GASDSignature984::histogram
float histogram[984]
Definition: point_types.hpp:1654
pcl::GASDSignature984::operator<<
friend std::ostream & operator<<(std::ostream &os, const GASDSignature984 &p)
pcl::GASDSignature984::GASDSignature984
GASDSignature984()=default
pcl::GASDSignature984::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1655
pcl::GFPFHSignature16
A point structure representing the GFPFH descriptor with 16 bins.
Definition: point_types.hpp:1681
pcl::GFPFHSignature16::operator<<
friend std::ostream & operator<<(std::ostream &os, const GFPFHSignature16 &p)
pcl::GFPFHSignature16::GFPFHSignature16
GFPFHSignature16()=default
pcl::GFPFHSignature16::histogram
float histogram[16]
Definition: point_types.hpp:1682
pcl::GFPFHSignature16::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1683
pcl::GRSDSignature21
A point structure representing the Global Radius-based Surface Descriptor (GRSD).
Definition: point_types.hpp:1593
pcl::GRSDSignature21::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1595
pcl::GRSDSignature21::GRSDSignature21
GRSDSignature21()=default
pcl::GRSDSignature21::histogram
float histogram[21]
Definition: point_types.hpp:1594
pcl::GRSDSignature21::operator<<
friend std::ostream & operator<<(std::ostream &os, const GRSDSignature21 &p)
pcl::Histogram
A point structure representing an N-D histogram.
Definition: point_types.hpp:1758
pcl::Histogram::histogram
float histogram[N]
Definition: point_types.hpp:1759
pcl::Histogram::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1760
pcl::Intensity32u
A point structure representing the grayscale intensity in single-channel images.
Definition: point_types.hpp:478
pcl::Intensity32u::operator<<
friend std::ostream & operator<<(std::ostream &os, const Intensity32u &p)
pcl::Intensity32u::Intensity32u
Intensity32u(std::uint32_t _intensity=0)
Definition: point_types.hpp:484
pcl::Intensity32u::Intensity32u
Intensity32u(const _Intensity32u &p)
Definition: point_types.hpp:479
pcl::Intensity8u
A point structure representing the grayscale intensity in single-channel images.
Definition: point_types.hpp:446
pcl::Intensity8u::operator<<
friend std::ostream & operator<<(std::ostream &os, const Intensity8u &p)
pcl::Intensity8u::Intensity8u
Intensity8u(const _Intensity8u &p)
Definition: point_types.hpp:447
pcl::Intensity8u::Intensity8u
Intensity8u(std::uint8_t _intensity=0)
Definition: point_types.hpp:452
pcl::IntensityGradient
A point structure representing the intensity gradient of an XYZI point cloud.
Definition: point_types.hpp:1733
pcl::IntensityGradient::gradient
float gradient[3]
Definition: point_types.hpp:1736
pcl::IntensityGradient::gradient_x
float gradient_x
Definition: point_types.hpp:1739
pcl::IntensityGradient::operator<<
friend std::ostream & operator<<(std::ostream &os, const IntensityGradient &p)
pcl::IntensityGradient::IntensityGradient
IntensityGradient(float _x, float _y, float _z)
Definition: point_types.hpp:1747
pcl::IntensityGradient::gradient_z
float gradient_z
Definition: point_types.hpp:1741
pcl::IntensityGradient::gradient_y
float gradient_y
Definition: point_types.hpp:1740
pcl::IntensityGradient::IntensityGradient
IntensityGradient()
Definition: point_types.hpp:1745
pcl::Intensity
A point structure representing the grayscale intensity in single-channel images.
Definition: point_types.hpp:420
pcl::Intensity::operator<<
friend std::ostream & operator<<(std::ostream &os, const Intensity &p)
pcl::Intensity::Intensity
Intensity(float _intensity=0.f)
Definition: point_types.hpp:426
pcl::Intensity::Intensity
Intensity(const _Intensity &p)
Definition: point_types.hpp:421
pcl::InterestPoint
A point structure representing an interest point with Euclidean xyz coordinates, and an interest valu...
Definition: point_types.hpp:866
pcl::InterestPoint::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: point_types.hpp:867
pcl::InterestPoint::strength
float strength
Definition: point_types.hpp:872
pcl::Label
Definition: point_types.hpp:562
pcl::Label::operator<<
friend std::ostream & operator<<(std::ostream &os, const Label &p)
pcl::Label::Label
Label(std::uint32_t _label=0)
Definition: point_types.hpp:565
pcl::Label::label
std::uint32_t label
Definition: point_types.hpp:563
pcl::MomentInvariants
A point structure representing the three moment invariants.
Definition: point_types.hpp:1271
pcl::MomentInvariants::MomentInvariants
MomentInvariants(float _j1, float _j2, float _j3)
Definition: point_types.hpp:1276
pcl::MomentInvariants::j1
float j1
Definition: point_types.hpp:1272
pcl::MomentInvariants::j2
float j2
Definition: point_types.hpp:1272
pcl::MomentInvariants::j3
float j3
Definition: point_types.hpp:1272
pcl::MomentInvariants::operator<<
friend std::ostream & operator<<(std::ostream &os, const MomentInvariants &p)
pcl::MomentInvariants::MomentInvariants
MomentInvariants()=default
pcl::Narf36
A point structure representing the Narf descriptor.
Definition: point_types.hpp:1695
pcl::Narf36::roll
float roll
Definition: point_types.hpp:1696
pcl::Narf36::pitch
float pitch
Definition: point_types.hpp:1696
pcl::Narf36::z
float z
Definition: point_types.hpp:1696
pcl::Narf36::Narf36
Narf36()=default
pcl::Narf36::y
float y
Definition: point_types.hpp:1696
pcl::Narf36::operator<<
friend std::ostream & operator<<(std::ostream &os, const Narf36 &p)
pcl::Narf36::yaw
float yaw
Definition: point_types.hpp:1696
pcl::Narf36::Narf36
Narf36(float _x, float _y, float _z)
Definition: point_types.hpp:1702
pcl::Narf36::descriptor
float descriptor[36]
Definition: point_types.hpp:1697
pcl::Narf36::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1698
pcl::Narf36::Narf36
Narf36(float _x, float _y, float _z, float _roll, float _pitch, float _yaw)
Definition: point_types.hpp:1704
pcl::Narf36::x
float x
Definition: point_types.hpp:1696
pcl::NormalBasedSignature12
A point structure representing the Normal Based Signature for a feature matrix of 4-by-3.
Definition: point_types.hpp:1440
pcl::NormalBasedSignature12::NormalBasedSignature12
NormalBasedSignature12()=default
pcl::NormalBasedSignature12::values
float values[12]
Definition: point_types.hpp:1441
pcl::NormalBasedSignature12::operator<<
friend std::ostream & operator<<(std::ostream &os, const NormalBasedSignature12 &p)
pcl::Normal
A point structure representing normal coordinates and the surface curvature estimate.
Definition: point_types.hpp:900
pcl::Normal::Normal
Normal(const _Normal &p)
Definition: point_types.hpp:901
pcl::Normal::Normal
Normal(float _curvature=0.f)
Definition: point_types.hpp:908
pcl::Normal::operator<<
friend std::ostream & operator<<(std::ostream &os, const Normal &p)
pcl::Normal::Normal
Normal(float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:910
pcl::PCLPointField
Definition: PCLPointField.h:13
pcl::PCLPointField::FLOAT32
@ FLOAT32
Definition: PCLPointField.h:26
pcl::PCLPointField::UINT32
@ UINT32
Definition: PCLPointField.h:25
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:1367
pcl::PFHRGBSignature250::PFHRGBSignature250
PFHRGBSignature250()=default
pcl::PFHRGBSignature250::histogram
float histogram[250]
Definition: point_types.hpp:1368
pcl::PFHRGBSignature250::operator<<
friend std::ostream & operator<<(std::ostream &os, const PFHRGBSignature250 &p)
pcl::PFHRGBSignature250::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1369
pcl::PFHSignature125
A point structure representing the Point Feature Histogram (PFH).
Definition: point_types.hpp:1352
pcl::PFHSignature125::histogram
float histogram[125]
Definition: point_types.hpp:1353
pcl::PFHSignature125::PFHSignature125
PFHSignature125()=default
pcl::PFHSignature125::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1354
pcl::PFHSignature125::operator<<
friend std::ostream & operator<<(std::ostream &os, const PFHSignature125 &p)
pcl::PPFRGBSignature
A point structure for storing the Point Pair Color Feature (PPFRGB) values.
Definition: point_types.hpp:1418
pcl::PPFRGBSignature::f1
float f1
Definition: point_types.hpp:1419
pcl::PPFRGBSignature::PPFRGBSignature
PPFRGBSignature(float _f1, float _f2, float _f3, float _f4, float _alpha, float _r, float _g, float _b)
Definition: point_types.hpp:1428
pcl::PPFRGBSignature::PPFRGBSignature
PPFRGBSignature(float _f1, float _f2, float _f3, float _f4, float _alpha=0.f)
Definition: point_types.hpp:1425
pcl::PPFRGBSignature::alpha_m
float alpha_m
Definition: point_types.hpp:1421
pcl::PPFRGBSignature::f4
float f4
Definition: point_types.hpp:1419
pcl::PPFRGBSignature::f2
float f2
Definition: point_types.hpp:1419
pcl::PPFRGBSignature::g_ratio
float g_ratio
Definition: point_types.hpp:1420
pcl::PPFRGBSignature::b_ratio
float b_ratio
Definition: point_types.hpp:1420
pcl::PPFRGBSignature::operator<<
friend std::ostream & operator<<(std::ostream &os, const PPFRGBSignature &p)
pcl::PPFRGBSignature::f3
float f3
Definition: point_types.hpp:1419
pcl::PPFRGBSignature::r_ratio
float r_ratio
Definition: point_types.hpp:1420
pcl::PPFRGBSignature::PPFRGBSignature
PPFRGBSignature(float _alpha=0.f)
Definition: point_types.hpp:1423
pcl::PPFSignature
A point structure for storing the Point Pair Feature (PPF) values.
Definition: point_types.hpp:1381
pcl::PPFSignature::f2
float f2
Definition: point_types.hpp:1382
pcl::PPFSignature::f4
float f4
Definition: point_types.hpp:1382
pcl::PPFSignature::operator<<
friend std::ostream & operator<<(std::ostream &os, const PPFSignature &p)
pcl::PPFSignature::alpha_m
float alpha_m
Definition: point_types.hpp:1383
pcl::PPFSignature::PPFSignature
PPFSignature(float _f1, float _f2, float _f3, float _f4, float _alpha=0.f)
Definition: point_types.hpp:1387
pcl::PPFSignature::f1
float f1
Definition: point_types.hpp:1382
pcl::PPFSignature::PPFSignature
PPFSignature(float _alpha=0.f)
Definition: point_types.hpp:1385
pcl::PPFSignature::f3
float f3
Definition: point_types.hpp:1382
pcl::PointDEM
A point structure representing Digital Elevation Map.
Definition: point_types.hpp:1879
pcl::PointDEM::PointDEM
PointDEM()
Definition: point_types.hpp:1888
pcl::PointDEM::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointDEM &p)
pcl::PointDEM::PointDEM
PointDEM(const _PointDEM &p)
Definition: point_types.hpp:1880
pcl::PointDEM::PointDEM
PointDEM(float _x, float _y, float _z, float _intensity, float _intensity_variance, float _height_variance)
Definition: point_types.hpp:1892
pcl::PointDEM::PointDEM
PointDEM(float _x, float _y, float _z)
Definition: point_types.hpp:1890
pcl::PointNormal
A point structure representing Euclidean xyz coordinates, together with normal coordinates and the su...
Definition: point_types.hpp:973
pcl::PointNormal::PointNormal
PointNormal(float _x, float _y, float _z)
Definition: point_types.hpp:983
pcl::PointNormal::PointNormal
PointNormal(float _curvature=0.f)
Definition: point_types.hpp:981
pcl::PointNormal::PointNormal
PointNormal(const _PointNormal &p)
Definition: point_types.hpp:974
pcl::PointNormal::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointNormal &p)
pcl::PointNormal::PointNormal
PointNormal(float _x, float _y, float _z, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:986
pcl::PointSurfel
A surfel, that is, a point structure representing Euclidean xyz coordinates, together with normal coo...
Definition: point_types.hpp:1840
pcl::PointSurfel::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointSurfel &p)
pcl::PointSurfel::PointSurfel
PointSurfel()
Definition: point_types.hpp:1850
pcl::PointSurfel::PointSurfel
PointSurfel(const _PointSurfel &p)
Definition: point_types.hpp:1841
pcl::PointUV
A 2D point structure representing pixel image coordinates.
Definition: point_types.hpp:849
pcl::PointUV::u
float u
Definition: point_types.hpp:850
pcl::PointUV::PointUV
PointUV()=default
pcl::PointUV::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointUV &p)
pcl::PointUV::PointUV
PointUV(float _u, float _v)
Definition: point_types.hpp:855
pcl::PointUV::v
float v
Definition: point_types.hpp:851
pcl::PointWithRange
A point structure representing Euclidean xyz coordinates, padded with an extra range float.
Definition: point_types.hpp:1204
pcl::PointWithRange::PointWithRange
PointWithRange(const _PointWithRange &p)
Definition: point_types.hpp:1205
pcl::PointWithRange::PointWithRange
PointWithRange(float _x, float _y, float _z, float _range=0.f)
Definition: point_types.hpp:1213
pcl::PointWithRange::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointWithRange &p)
pcl::PointWithRange::PointWithRange
PointWithRange(float _range=0.f)
Definition: point_types.hpp:1211
pcl::PointWithScale
A point structure representing a 3-D position and scale.
Definition: point_types.hpp:1789
pcl::PointWithScale::PointWithScale
PointWithScale(float _x, float _y, float _z, float _scale=1.f, float _angle=-1.f, float _response=0.f, int _octave=0)
Definition: point_types.hpp:1801
pcl::PointWithScale::PointWithScale
PointWithScale()
Definition: point_types.hpp:1799
pcl::PointWithScale::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointWithScale &p)
pcl::PointWithScale::PointWithScale
PointWithScale(const _PointWithScale &p)
Definition: point_types.hpp:1790
pcl::PointWithViewpoint
A point structure representing Euclidean xyz coordinates together with the viewpoint from which it wa...
Definition: point_types.hpp:1245
pcl::PointWithViewpoint::PointWithViewpoint
PointWithViewpoint(float _x, float _y, float _z, float _vp_x, float _vp_y, float _vp_z)
Definition: point_types.hpp:1256
pcl::PointWithViewpoint::PointWithViewpoint
PointWithViewpoint(float _x, float _y, float _z)
Definition: point_types.hpp:1254
pcl::PointWithViewpoint::PointWithViewpoint
PointWithViewpoint()
Definition: point_types.hpp:1252
pcl::PointWithViewpoint::PointWithViewpoint
PointWithViewpoint(const _PointWithViewpoint &p)
Definition: point_types.hpp:1246
pcl::PointXY
A 2D point structure representing Euclidean xy coordinates.
Definition: point_types.hpp:832
pcl::PointXY::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXY &p)
pcl::PointXY::y
float y
Definition: point_types.hpp:834
pcl::PointXY::x
float x
Definition: point_types.hpp:833
pcl::PointXY::PointXY
PointXY(float _x, float _y)
Definition: point_types.hpp:838
pcl::PointXY::PointXY
PointXY()=default
pcl::PointXYZHSV
Definition: point_types.hpp:798
pcl::PointXYZHSV::PointXYZHSV
PointXYZHSV(const _PointXYZHSV &p)
Definition: point_types.hpp:799
pcl::PointXYZHSV::PointXYZHSV
PointXYZHSV(float _x, float _y, float _z, float _h, float _s, float _v)
Definition: point_types.hpp:812
pcl::PointXYZHSV::PointXYZHSV
PointXYZHSV()
Definition: point_types.hpp:805
pcl::PointXYZHSV::PointXYZHSV
PointXYZHSV(float _h, float _s, float _v)
Definition: point_types.hpp:809
pcl::PointXYZ
A point structure representing Euclidean xyz coordinates.
Definition: point_types.hpp:347
pcl::PointXYZ::PointXYZ
PointXYZ()
Definition: point_types.hpp:350
pcl::PointXYZ::PointXYZ
PointXYZ(const _PointXYZ &p)
Definition: point_types.hpp:348
pcl::PointXYZ::PointXYZ
PointXYZ(float _x, float _y, float _z)
Definition: point_types.hpp:352
pcl::PointXYZI
Definition: point_types.hpp:511
pcl::PointXYZI::PointXYZI
PointXYZI(float _x, float _y, float _z, float _intensity=0.f)
Definition: point_types.hpp:520
pcl::PointXYZI::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZI &p)
pcl::PointXYZI::PointXYZI
PointXYZI(const _PointXYZI &p)
Definition: point_types.hpp:512
pcl::PointXYZI::PointXYZI
PointXYZI(float _intensity=0.f)
Definition: point_types.hpp:518
pcl::PointXYZINormal
A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates...
Definition: point_types.hpp:1104
pcl::PointXYZINormal::PointXYZINormal
PointXYZINormal(float _x, float _y, float _z, float _intensity=0.f)
Definition: point_types.hpp:1115
pcl::PointXYZINormal::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZINormal &p)
pcl::PointXYZINormal::PointXYZINormal
PointXYZINormal(float _x, float _y, float _z, float _intensity, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:1118
pcl::PointXYZINormal::PointXYZINormal
PointXYZINormal(const _PointXYZINormal &p)
Definition: point_types.hpp:1105
pcl::PointXYZINormal::PointXYZINormal
PointXYZINormal(float _intensity=0.f)
Definition: point_types.hpp:1113
pcl::PointXYZLAB
A point structure representing Euclidean xyz coordinates, and the CIELAB color.
Definition: point_types.hpp:760
pcl::PointXYZLAB::PointXYZLAB
PointXYZLAB()
Definition: point_types.hpp:767
pcl::PointXYZLAB::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZLAB &p)
pcl::PointXYZLAB::PointXYZLAB
PointXYZLAB(const _PointXYZLAB &p)
Definition: point_types.hpp:761
pcl::PointXYZL
Definition: point_types.hpp:540
pcl::PointXYZL::PointXYZL
PointXYZL(float _x, float _y, float _z, std::uint32_t _label=0)
Definition: point_types.hpp:549
pcl::PointXYZL::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZL &p)
pcl::PointXYZL::PointXYZL
PointXYZL(const _PointXYZL &p)
Definition: point_types.hpp:541
pcl::PointXYZL::PointXYZL
PointXYZL(std::uint32_t _label=0)
Definition: point_types.hpp:547
pcl::PointXYZLNormal
A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates a...
Definition: point_types.hpp:1154
pcl::PointXYZLNormal::PointXYZLNormal
PointXYZLNormal(float _x, float _y, float _z, std::uint32_t _label=0.f)
Definition: point_types.hpp:1165
pcl::PointXYZLNormal::PointXYZLNormal
PointXYZLNormal(float _x, float _y, float _z, std::uint32_t _label, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:1168
pcl::PointXYZLNormal::PointXYZLNormal
PointXYZLNormal(const _PointXYZLNormal &p)
Definition: point_types.hpp:1155
pcl::PointXYZLNormal::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZLNormal &p)
pcl::PointXYZLNormal::PointXYZLNormal
PointXYZLNormal(std::uint32_t _label=0)
Definition: point_types.hpp:1163
pcl::PointXYZRGBA
A point structure representing Euclidean xyz coordinates, and the RGBA color.
Definition: point_types.hpp:600
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
Definition: point_types.hpp:609
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA(const _PointXYZRGBA &p)
Definition: point_types.hpp:601
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA()
Definition: point_types.hpp:607
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA(float _x, float _y, float _z)
Definition: point_types.hpp:612
pcl::PointXYZRGBA::PointXYZRGBA
PointXYZRGBA(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint8_t _a)
Definition: point_types.hpp:615
pcl::PointXYZRGB
A point structure representing Euclidean xyz coordinates, and the RGB color.
Definition: point_types.hpp:675
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:690
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB(const _PointXYZRGB &p)
Definition: point_types.hpp:676
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB(float _x, float _y, float _z)
Definition: point_types.hpp:687
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB()
Definition: point_types.hpp:682
pcl::PointXYZRGB::PointXYZRGB
PointXYZRGB(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:684
pcl::PointXYZRGBL
Definition: point_types.hpp:706
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(std::uint32_t _label=0)
Definition: point_types.hpp:714
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(const _PointXYZRGBL &p)
Definition: point_types.hpp:707
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, std::uint32_t _label=0)
Definition: point_types.hpp:723
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(float _x, float _y, float _z)
Definition: point_types.hpp:720
pcl::PointXYZRGBL::PointXYZRGBL
PointXYZRGBL(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:717
pcl::PointXYZRGBNormal
A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coo...
Definition: point_types.hpp:1047
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b, float n_x, float n_y, float n_z, float _curvature=0.f)
Definition: point_types.hpp:1068
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(float _x, float _y, float _z)
Definition: point_types.hpp:1059
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(float _x, float _y, float _z, std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:1065
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(float _curvature=0.f)
Definition: point_types.hpp:1056
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(const _PointXYZRGBNormal &p)
Definition: point_types.hpp:1048
pcl::PointXYZRGBNormal::operator<<
friend std::ostream & operator<<(std::ostream &os, const PointXYZRGBNormal &p)
pcl::PointXYZRGBNormal::PointXYZRGBNormal
PointXYZRGBNormal(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:1062
pcl::PrincipalCurvatures
A point structure representing the principal curvatures and their magnitudes.
Definition: point_types.hpp:1321
pcl::PrincipalCurvatures::PrincipalCurvatures
PrincipalCurvatures()
Definition: point_types.hpp:1335
pcl::PrincipalCurvatures::pc2
float pc2
Definition: point_types.hpp:1333
pcl::PrincipalCurvatures::operator<<
friend std::ostream & operator<<(std::ostream &os, const PrincipalCurvatures &p)
pcl::PrincipalCurvatures::PrincipalCurvatures
PrincipalCurvatures(float _x, float _y, float _z, float _pc1, float _pc2)
Definition: point_types.hpp:1341
pcl::PrincipalCurvatures::PrincipalCurvatures
PrincipalCurvatures(float _pc1, float _pc2)
Definition: point_types.hpp:1337
pcl::PrincipalCurvatures::PrincipalCurvatures
PrincipalCurvatures(float _x, float _y, float _z)
Definition: point_types.hpp:1339
pcl::PrincipalCurvatures::principal_curvature_x
float principal_curvature_x
Definition: point_types.hpp:1327
pcl::PrincipalCurvatures::pc1
float pc1
Definition: point_types.hpp:1332
pcl::PrincipalCurvatures::principal_curvature_z
float principal_curvature_z
Definition: point_types.hpp:1329
pcl::PrincipalCurvatures::principal_curvature_y
float principal_curvature_y
Definition: point_types.hpp:1328
pcl::PrincipalCurvatures::principal_curvature
float principal_curvature[3]
Definition: point_types.hpp:1324
pcl::PrincipalRadiiRSD
A point structure representing the minimum and maximum surface radii (in meters) computed using RSD.
Definition: point_types.hpp:1286
pcl::PrincipalRadiiRSD::PrincipalRadiiRSD
PrincipalRadiiRSD()=default
pcl::PrincipalRadiiRSD::r_min
float r_min
Definition: point_types.hpp:1287
pcl::PrincipalRadiiRSD::r_max
float r_max
Definition: point_types.hpp:1287
pcl::PrincipalRadiiRSD::PrincipalRadiiRSD
PrincipalRadiiRSD(float _r_min, float _r_max)
Definition: point_types.hpp:1291
pcl::PrincipalRadiiRSD::operator<<
friend std::ostream & operator<<(std::ostream &os, const PrincipalRadiiRSD &p)
pcl::RGB
A structure representing RGB color information.
Definition: point_types.hpp:392
pcl::RGB::RGB
RGB()
Definition: point_types.hpp:398
pcl::RGB::operator<<
friend std::ostream & operator<<(std::ostream &os, const RGB &p)
pcl::RGB::RGB
RGB(const _RGB &p)
Definition: point_types.hpp:393
pcl::RGB::RGB
RGB(std::uint8_t _r, std::uint8_t _g, std::uint8_t _b)
Definition: point_types.hpp:400
pcl::ReferenceFrame
Definition: point_types.hpp:1540
pcl::ReferenceFrame::ReferenceFrame
ReferenceFrame(const _ReferenceFrame &p)
Definition: point_types.hpp:1541
pcl::ReferenceFrame::ReferenceFrame
ReferenceFrame()
Definition: point_types.hpp:1546
pcl::SHOT1344
A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+col...
Definition: point_types.hpp:1499
pcl::SHOT1344::descriptor
float descriptor[1344]
Definition: point_types.hpp:1500
pcl::SHOT1344::operator<<
friend std::ostream & operator<<(std::ostream &os, const SHOT1344 &p)
pcl::SHOT1344::SHOT1344
SHOT1344()=default
pcl::SHOT1344::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1502
pcl::SHOT1344::rf
float rf[9]
Definition: point_types.hpp:1501
pcl::SHOT352
A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape onl...
Definition: point_types.hpp:1483
pcl::SHOT352::descriptor
float descriptor[352]
Definition: point_types.hpp:1484
pcl::SHOT352::SHOT352
SHOT352()=default
pcl::SHOT352::operator<<
friend std::ostream & operator<<(std::ostream &os, const SHOT352 &p)
pcl::SHOT352::rf
float rf[9]
Definition: point_types.hpp:1485
pcl::SHOT352::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1486
pcl::ShapeContext1980
A point structure representing a Shape Context.
Definition: point_types.hpp:1453
pcl::ShapeContext1980::operator<<
friend std::ostream & operator<<(std::ostream &os, const ShapeContext1980 &p)
pcl::ShapeContext1980::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1456
pcl::ShapeContext1980::ShapeContext1980
ShapeContext1980()=default
pcl::ShapeContext1980::descriptor
float descriptor[1980]
Definition: point_types.hpp:1454
pcl::ShapeContext1980::rf
float rf[9]
Definition: point_types.hpp:1455
pcl::UniqueShapeContext1960
A point structure representing a Unique Shape Context.
Definition: point_types.hpp:1468
pcl::UniqueShapeContext1960::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1471
pcl::UniqueShapeContext1960::operator<<
friend std::ostream & operator<<(std::ostream &os, const UniqueShapeContext1960 &p)
pcl::UniqueShapeContext1960::UniqueShapeContext1960
UniqueShapeContext1960()=default
pcl::UniqueShapeContext1960::descriptor
float descriptor[1960]
Definition: point_types.hpp:1469
pcl::UniqueShapeContext1960::rf
float rf[9]
Definition: point_types.hpp:1470
pcl::VFHSignature308
A point structure representing the Viewpoint Feature Histogram (VFH).
Definition: point_types.hpp:1579
pcl::VFHSignature308::histogram
float histogram[308]
Definition: point_types.hpp:1580
pcl::VFHSignature308::descriptorSize
static constexpr int descriptorSize()
Definition: point_types.hpp:1581
pcl::VFHSignature308::operator<<
friend std::ostream & operator<<(std::ostream &os, const VFHSignature308 &p)
pcl::VFHSignature308::VFHSignature308
VFHSignature308()=default
pcl::detail::traits::descriptorSize
Definition: point_types.hpp:196