pcl Namespace Reference

Namespaces
namespace	ComparisonOps
namespace	detail
namespace	fields
namespace	io
namespace	msg
namespace	registration
namespace	traits
Classes
struct	_PointWithViewpoint
struct	_PointXYZ
class	BivariatePolynomialT
	This represents a bivariate polynomial and provides some functionality for it More...
struct	BorderDescription
struct	Boundary
class	BoundaryEstimation
	BoundaryEstimation estimates whether a set of points is lying on surface boundaries using an angle criterion. The code makes use of the estimated surface normals at each point in the input dataset. More...
class	ComparisonBase
	The (abstract) base class for the comparison object. More...
class	ConcaveHull
	ConcaveHull (alpha shapes) using libqhull library. More...
class	ConditionalRemoval
	ConditionalRemoval filters data that satisfies certain conditions. More...
class	ConditionAnd
	AND condition. More...
class	ConditionBase
	Base condition class. More...
class	ConditionOr
	OR condition. More...
class	ConvexHull
	ConvexHull using libqhull library. More...
class	DefaultPointRepresentation
	DefaultPointRepresentation extends PointRepresentation to define default behavior for common point types. More...
class	DefaultPointRepresentation< FPFHSignature33 >
class	DefaultPointRepresentation< PFHSignature125 >
class	DefaultPointRepresentation< PointNormal >
class	DefaultPointRepresentation< PointXYZ >
class	DefaultPointRepresentation< PointXYZI >
class	EuclideanClusterExtraction
	EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense. More...
class	ExtractIndices
	ExtractIndices extracts a set of indices from a PointCloud as a separate PointCloud. More...
class	ExtractIndices< sensor_msgs::PointCloud2 >
	ExtractIndices extracts a set of indices from a PointCloud as a separate PointCloud. More...
class	ExtractPolygonalPrismData
	ExtractPolygonalPrismData uses a set of point indices that represent a planar model, and together with a given height, generates a 3D polygonal prism. The polygonal prism is then used to segment all points lying inside it. More...
class	Feature
	Feature represents the base feature class. Some generic 3D operations that are applicable to all features are defined here as static methods. More...
class	FeatureFromNormals
class	FieldComparison
	The field-based specialization of the comparison object. More...
class	Filter
	Filter represents the base filter class. Some generic 3D operations that are applicable to all filters are defined here as static methods. More...
class	Filter< sensor_msgs::PointCloud2 >
	Filter represents the base filter class. Some generic 3D operations that are applicable to all filters are defined here as static methods. More...
struct	for_each_type_impl
struct	for_each_type_impl< false >
class	FPFHEstimation
	FPFHEstimation estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals. More...
class	FPFHEstimationOMP
	FPFHEstimationOMP estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals, in parallel, using the OpenMP standard. More...
struct	FPFHSignature33
class	GreedyProjectionTriangulation
	GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points based on local 2D projections. It assumes locally smooth surfaces and relatively smooth transitions between areas with different point densities. More...
class	GridProjection
	Grid projection surface reconstruction method. More...
struct	Histogram
class	IntegralImage2D
	Generic implementation for creating 2D integral images (including second order integral images). More...
class	IntegralImageNormalEstimation
	Surface normal estimation on dense data using integral images. More...
struct	IntensityGradient
class	IntensityGradientEstimation
	IntensityGradientEstimation estimates the intensity gradient for a point cloud that contains position and intensity values. The intensity gradient at a given point will be a vector orthogonal to the surface normal and pointing in the direction of the greatest increase in local intensity; the vector's magnitude indicates the rate of intensity change. More...
class	IntensitySpinEstimation
	IntensitySpinEstimation estimates the intensity-domain spin image descriptors for a given point cloud dataset containing points and intensity. For more information about the intensity-domain spin image descriptor, see: More...
struct	InterestPoint
class	InvalidConversionException
	An exception that is thrown when a PointCloud2 message cannot be converted into a PCL type. More...
class	IsNotDenseException
	An exception that is thrown when a PointCloud is not dense but is attemped to be used as dense. More...
class	IterativeClosestPoint
	IterativeClosestPoint is an implementation of the Iterative Closest Point algorithm based on Singular Value Decomposition (SVD). More...
class	IterativeClosestPointNonLinear
	IterativeClosestPointNonLinear is an ICP variant that uses Levenberg-Marquardt optimization backend. The resultant transformation is optimized as a quaternion. More...
class	KdTree
	KdTree represents the base spatial locator class for nearest neighbor estimation. All types of spatial locators should inherit from KdTree. More...
class	KdTreeFLANN
	KdTreeFLANN is a generic type of 3D spatial locator using kD-tree structures. The class is making use of the FLANN (Fast Library for Approximate Nearest Neighbor) project by Marius Muja and David Lowe. More...
class	Keypoint
	Keypoint represents the base class for key points. More...
class	LeastMedianSquares
	LeastMedianSquares represents an implementation of the LMedS (Least Median of Squares) algorithm. LMedS is a RANSAC-like model-fitting algorithm that can tolerate up to 50% outliers without requiring thresholds to be set. See Andrea Fusiello's "Elements of Geometric Computer Vision" (http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/FUSIELLO4/tutorial.html#x1-520007) for more details. More...
class	MaximumLikelihoodSampleConsensus
	MaximumLikelihoodSampleConsensus represents an implementation of the MLESAC (Maximum Likelihood Estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S. Torr and A. Zisserman, Computer Vision and Image Understanding, vol 78, 2000. More...
class	MEstimatorSampleConsensus
	MEstimatorSampleConsensus represents an implementation of the MSAC (M-estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S. Torr and A. Zisserman, Computer Vision and Image Understanding, vol 78, 2000. More...
struct	ModelCoefficients_
struct	MomentInvariants
class	MomentInvariantsEstimation
	MomentInvariantsEstimation estimates the 3 moment invariants (j1, j2, j3) at each 3D point. More...
class	MovingLeastSquares
	MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm for data smoothing and improved normal estimation. More...
class	Narf
	NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data. Please refer to pcl/features/narf_descriptor.h if you want the class derived from pcl Feature. More...
struct	Narf36
class	NarfDescriptor
class	NarfKeypoint
	NARF (Normal Aligned Radial Feature) keypoints. Input is a range image, output the indices of the keypoints More...
struct	NdCentroidFunctor
	Helper functor structure for n-D centroid estimation. More...
struct	NdConcatenateFunctor
	Helper functor structure for concatenate. More...
struct	NdCopyEigenPointFunctor
	Helper functor structure for copying data between an Eigen::VectorXf and a PointT. More...
struct	NdCopyPointEigenFunctor
	Helper functor structure for copying data between an Eigen::VectorXf and a PointT. More...
struct	Normal
class	NormalEstimation
	NormalEstimation estimates local surface properties at each 3D point, such as surface normals and curvatures. More...
class	NormalEstimationOMP
	NormalEstimationOMP estimates local surface properties at each 3D point, such as surface normals and curvatures, in parallel, using the OpenMP standard. More...
class	NormalEstimationTBB
	NormalEstimationTBB estimates local surface properties at each 3D point, such as surface normals and curvatures, in parallel, using Intel's Threading Building Blocks library. More...
class	OrganizedDataIndex
	OrganizedDataIndex is a type of spatial locator used to query organized datasets, such as point clouds acquired using dense stereo devices. The class best supports square data blocks for now in the form of (k*k+1)^2. More...
class	PackedHSIComparison
	A packed HSI specialization of the comparison object. More...
class	PackedRGBComparison
	A packed rgb specialization of the comparison object. More...
class	PassThrough
	PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints. More...
class	PassThrough< sensor_msgs::PointCloud2 >
	PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints. More...
class	PCDReader
	Point Cloud Data (PCD) file format reader. More...
class	PCDWriter
	Point Cloud Data (PCD) file format writer. More...
class	PCLBase
	PCL base class. Implements methods that are used by all PCL objects. More...
class	PCLBase< sensor_msgs::PointCloud2 >
class	PCLException
	A base class for all pcl exceptions which inherits from std::runtime_error. More...
class	PFHEstimation
	PFHEstimation estimates the Point Feature Histogram (PFH) descriptor for a given point cloud dataset containing points and normals. More...
struct	PFHSignature125
class	PiecewiseLinearFunction
	This provides functionalities to efficiently return values for piecewise linear function. More...
class	PointCloud
struct	PointCorrespondence
	Representation of a (possible) correspondence between two points in two different coordinate frames (e.g. from feature matching). More...
struct	PointCorrespondence3D
	Representation of a (possible) correspondence between two 3D points in two different coordinate frames (e.g. from feature matching). More...
struct	PointCorrespondence6D
	Representation of a (possible) correspondence between two points (e.g. from feature matching), that encode complete 6DOF transoformations. More...
class	PointDataAtOffset
	A datatype that enables type-correct comparisons. More...
struct	PointIndices_
struct	PointNormal
class	PointRepresentation
	PointRepresentation provides a set of methods for converting a point structs/object into an n-dimensional vector. More...
struct	PointSurfel
struct	PointWithRange
struct	PointWithScale
struct	PointWithViewpoint
struct	PointXY
struct	PointXYZ
struct	PointXYZI
struct	PointXYZINormal
struct	PointXYZRGB
struct	PointXYZRGBA
struct	PointXYZRGBNormal
struct	PolygonMesh_
class	PolynomialCalculationsT
	This provides some functionality for polynomials, like finding roots or approximating bivariate polynomials More...
class	PosesFromMatches
	calculate 3D transformation based on point correspondencdes More...
struct	PrincipalCurvatures
class	PrincipalCurvaturesEstimation
	PrincipalCurvaturesEstimation estimates the directions (eigenvectors) and magnitudes (eigenvalues) of principal surface curvatures for a given point cloud dataset containing points and normals. More...
struct	PrincipalRadiiRSD
class	ProgressiveSampleConsensus
	RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Matching with PROSAC – Progressive Sample Consensus", Chum, O. and Matas, J.G., CVPR, I: 220-226 2005. More...
class	ProjectInliers
	ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud. More...
class	ProjectInliers< sensor_msgs::PointCloud2 >
	ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud. More...
class	RadiusOutlierRemoval
	RadiusOutlierRemoval is a simple filter that removes outliers if the number of neighbors in a certain search radius is smaller than a given K. More...
class	RadiusOutlierRemoval< sensor_msgs::PointCloud2 >
	RadiusOutlierRemoval is a simple filter that removes outliers if the number of neighbors in a certain search radius is smaller than a given K. More...
class	RandomizedMEstimatorSampleConsensus
	RandomizedMEstimatorSampleConsensus represents an implementation of the RMSAC (Randomized M-estimator SAmple Consensus) algorithm, which basically adds a Td,d test (see RandomizedRandomSampleConsensus) to an MSAC estimator (see MEstimatorSampleConsensus). More...
class	RandomizedRandomSampleConsensus
	RandomizedRandomSampleConsensus represents an implementation of the RRANSAC (Randomized RAndom SAmple Consensus), as described in "Randomized RANSAC with Td,d test", O. Chum and J. Matas, Proc. British Machine Vision Conf. (BMVC '02), vol. 2, BMVA, pp. 448-457, 2002. More...
class	RandomSampleConsensus
	RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography", Martin A. Fischler and Robert C. Bolles, Comm. Of the ACM 24: 381–395, June 1981. More...
class	RangeImage
	RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where a 3D scene was captured from a specific view point. More...
class	RangeImageBorderExtractor
	Extract obstacle borders from range images, meaning positions where there is a transition from foreground to background. More...
class	RangeImagePlanar
	RangeImagePlanar is derived from the original range image and differs from it because it's not a spherical projection, but using a projection plane (as normal cameras do), therefore being better applicable for range sensors that already provide a range image by themselves (stereo cameras, kinect, ToF-cameras), so that a conversion to point cloud and then to a spherical range image becomes unnecessary. More...
class	Registration
	Registration represents the base registration class. All 3D registration methods should inherit from this class. More...
class	RIFTEstimation
	RIFTEstimation estimates the Rotation Invariant Feature Transform descriptors for a given point cloud dataset containing points and intensity. For more information about the RIFT descriptor, see: More...
class	RSDEstimation
	RSDEstimation estimates the Radius-based Surface Descriptor (minimal and maximal radius of the local surface's curves) for a given point cloud dataset containing points and normals. More...
class	SACSegmentation
	SACSegmentation represents the Nodelet segmentation class for Sample Consensus methods and models, in the sense that it just creates a Nodelet wrapper for generic-purpose SAC-based segmentation. More...
class	SACSegmentationFromNormals
	SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and models that require the use of surface normals for estimation. More...
class	SampleConsensus
	SampleConsensus represents the base class. All sample consensus methods must inherit from this class. More...
class	SampleConsensusInitialAlignment
	SampleConsensusInitialAlignment is an implementation of the initial alignment algorithm described in section IV of "Fast Point Feature Histograms (FPFH) for 3D Registration," Rusu et al. More...
class	SampleConsensusModel
	SampleConsensusModel represents the base model class. All sample consensus models must inherit from this class. More...
class	SampleConsensusModelCircle2D
	SampleConsensusModelCircle2D defines a model for 2D circle segmentation on the X-Y plane. More...
class	SampleConsensusModelCylinder
	SampleConsensusModelCylinder defines a model for 3D cylinder segmentation. More...
class	SampleConsensusModelFromNormals
	SampleConsensusModelFromNormals represents the base model class for models that require the use of surface normals for estimation. More...
class	SampleConsensusModelLine
	SampleConsensusModelLine defines a model for 3D line segmentation. More...
class	SampleConsensusModelNormalParallelPlane
	SampleConsensusModelNormalParallelPlane defines a model for 3D plane segmentation using additional surface normal constraints. The plane must lie parallel to a user-specified axis. More...
class	SampleConsensusModelNormalPlane
	SampleConsensusModelNormalPlane defines a model for 3D plane segmentation using additional surface normal constraints. More...
class	SampleConsensusModelParallelLine
	SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular constraints. More...
class	SampleConsensusModelParallelPlane
	SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional angular constraints. The plane must be parallel to a user-specified axis within a user-specified angle threshold. More...
class	SampleConsensusModelPerpendicularPlane
	SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional angular constraints. The plane must be perpendicular to a user-specified axis, up to a user-specified angle threshold. More...
class	SampleConsensusModelPlane
	SampleConsensusModelPlane defines a model for 3D plane segmentation. More...
class	SampleConsensusModelRegistration
	SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection. More...
class	SampleConsensusModelSphere
	SampleConsensusModelSphere defines a model for 3D sphere segmentation. More...
class	ScopeTime
	Class to measure the time spent in a scope. More...
class	SegmentDifferences
	SegmentDifferences obtains the difference between two spatially aligned point clouds and returns the difference between them for a maximum given distance threshold. More...
class	SIFTKeypoint
	SIFTKeypoint detects the Scale Invariant Feature Transform keypoints for a given point cloud dataset containing points and intensity. This implementation adapts the original algorithm from images to point clouds. For more information about the image-based SIFT interest operator, see: More...
class	StatisticalOutlierRemoval
	StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data. For more information check: More...
class	StatisticalOutlierRemoval< sensor_msgs::PointCloud2 >
	StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data. For more information check: More...
class	SurfaceReconstruction
	SurfaceReconstruction represents the base surface reconstruction class. More...
class	TBB_NormalEstimationTBB
class	TransformationFromCorrespondences
	Calculates a transformation based on corresponding 3D points. More...
class	VectorAverage
	Calculates the weighted average and the covariance matrix. More...
struct	Vertices_
class	VFHEstimation
	VFHEstimation estimates the Viewpoint Feature Histogram (VFH) descriptor for a given point cloud dataset containing points and normals. More...
struct	VFHSignature308
class	View
class	VoxelGrid
	VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data. More...
class	VoxelGrid< sensor_msgs::PointCloud2 >
	VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data. More...
Typedefs
typedef Eigen::Map < Eigen::Array3f >	Array3fMap
typedef const Eigen::Map < const Eigen::Array3f >	Array3fMapConst
typedef Eigen::Map < Eigen::Array4f, Eigen::Aligned >	Array4fMap
typedef const Eigen::Map < const Eigen::Array4f, Eigen::Aligned >	Array4fMapConst
typedef BivariatePolynomialT < float >	BivariatePolynomial
typedef BivariatePolynomialT < double >	BivariatePolynomiald
typedef std::bitset< 32 >	BorderTraits
	Data type to store extended information about a transition from foreground to backgroundSpecification of the fields for BorderDescription::traits.
typedef boost::shared_ptr < const std::vector< int > >	IndicesConstPtr
typedef boost::shared_ptr < std::vector< int > >	IndicesPtr
typedef ::pcl::ModelCoefficients_ < std::allocator< void > >	ModelCoefficients
typedef boost::shared_ptr < ::pcl::ModelCoefficients const >	ModelCoefficientsConstPtr
typedef boost::shared_ptr < ::pcl::ModelCoefficients >	ModelCoefficientsPtr
typedef std::vector < detail::FieldMapping >	MsgFieldMap
typedef std::vector < PointCorrespondence3D, Eigen::aligned_allocator < PointCorrespondence3D > >	PointCorrespondences3DVector
typedef std::vector < PointCorrespondence6D, Eigen::aligned_allocator < PointCorrespondence6D > >	PointCorrespondences6DVector
typedef ::pcl::PointIndices_ < std::allocator< void > >	PointIndices
typedef boost::shared_ptr < ::pcl::PointIndices const >	PointIndicesConstPtr
typedef boost::shared_ptr < ::pcl::PointIndices >	PointIndicesPtr
typedef ::pcl::PolygonMesh_ < std::allocator< void > >	PolygonMesh
typedef boost::shared_ptr < ::pcl::PolygonMesh const >	PolygonMeshConstPtr
typedef boost::shared_ptr < ::pcl::PolygonMesh >	PolygonMeshPtr
typedef PolynomialCalculationsT< float >	PolynomialCalculations
typedef PolynomialCalculationsT < double >	PolynomialCalculationsd
typedef Eigen::Map < Eigen::Vector3f >	Vector3fMap
typedef const Eigen::Map < const Eigen::Vector3f >	Vector3fMapConst
typedef Eigen::Map < Eigen::Vector4f, Eigen::Aligned >	Vector4fMap
typedef const Eigen::Map < const Eigen::Vector4f, Eigen::Aligned >	Vector4fMapConst
typedef VectorAverage< float, 2 >	VectorAverage2f
typedef VectorAverage< float, 3 >	VectorAverage3f
typedef VectorAverage< float, 4 >	VectorAverage4f
typedef ::pcl::Vertices_ < std::allocator< void > >	Vertices
typedef boost::shared_ptr < ::pcl::Vertices const >	VerticesConstPtr
typedef boost::shared_ptr < ::pcl::Vertices >	VerticesPtr
Enumerations
enum	BorderTrait { BORDER_TRAIT__OBSTACLE_BORDER, BORDER_TRAIT__SHADOW_BORDER, BORDER_TRAIT__VEIL_POINT, BORDER_TRAIT__SHADOW_BORDER_TOP, BORDER_TRAIT__SHADOW_BORDER_RIGHT, BORDER_TRAIT__SHADOW_BORDER_BOTTOM, BORDER_TRAIT__SHADOW_BORDER_LEFT, BORDER_TRAIT__OBSTACLE_BORDER_TOP, BORDER_TRAIT__OBSTACLE_BORDER_RIGHT, BORDER_TRAIT__OBSTACLE_BORDER_BOTTOM, BORDER_TRAIT__OBSTACLE_BORDER_LEFT, BORDER_TRAIT__VEIL_POINT_TOP, BORDER_TRAIT__VEIL_POINT_RIGHT, BORDER_TRAIT__VEIL_POINT_BOTTOM, BORDER_TRAIT__VEIL_POINT_LEFT }
	Specification of the fields for BorderDescription::traits. More...
enum	SacModel { SACMODEL_PLANE, SACMODEL_LINE, SACMODEL_CIRCLE2D, SACMODEL_CIRCLE3D, SACMODEL_SPHERE, SACMODEL_CYLINDER, SACMODEL_CONE, SACMODEL_TORUS, SACMODEL_PARALLEL_LINE, SACMODEL_PERPENDICULAR_PLANE, SACMODEL_PARALLEL_LINES, SACMODEL_NORMAL_PLANE, SACMODEL_REGISTRATION, SACMODEL_PARALLEL_PLANE, SACMODEL_NORMAL_PARALLEL_PLANE }
Functions
float	B_Norm (float A, float B, int dim)
	Compute the B norm of the vector between two points.
bool	comparePointClusters (const pcl::PointIndices &a, const pcl::PointIndices &b)
	Sort clusters method (for std::sort).
bool	comparePoints2D (const std::pair< int, Eigen::Vector4f > &p1, const std::pair< int, Eigen::Vector4f > &p2)
	Sort 2D points in a vector structure.
template<typename PointT >
void	compute3DCentroid (const pcl::PointCloud< PointT > &cloud, const pcl::PointIndices &indices, Eigen::Vector4f &centroid)
	Compute the 3D (X-Y-Z) centroid of a set of points using their indices and return it as a 3D vector.
template<typename PointT >
void	compute3DCentroid (const pcl::PointCloud< PointT > &cloud, const std::vector< int > &indices, Eigen::Vector4f &centroid)
	Compute the 3D (X-Y-Z) centroid of a set of points using their indices and return it as a 3D vector.
template<typename PointT >
void	compute3DCentroid (const pcl::PointCloud< PointT > &cloud, Eigen::Vector4f &centroid)
	Compute the 3D (X-Y-Z) centroid of a set of points and return it as a 3D vector.
template<typename PointT >
void	computeCovarianceMatrix (const pcl::PointCloud< PointT > &cloud, const pcl::PointIndices &indices, const Eigen::Vector4f &centroid, Eigen::Matrix3f &covariance_matrix)
	Compute the 3x3 covariance matrix of a given set of points using their indices. The result is returned as a Eigen::Matrix3f. Note: the covariance matrix is not normalized with the number of points. For a normalized covariance, please use computeNormalizedCovarianceMatrix.
template<typename PointT >
void	computeCovarianceMatrix (const pcl::PointCloud< PointT > &cloud, const std::vector< int > &indices, const Eigen::Vector4f &centroid, Eigen::Matrix3f &covariance_matrix)
	Compute the 3x3 covariance matrix of a given set of points using their indices. The result is returned as a Eigen::Matrix3f. Note: the covariance matrix is not normalized with the number of points. For a normalized covariance, please use computeNormalizedCovarianceMatrix.
template<typename PointT >
void	computeCovarianceMatrix (const pcl::PointCloud< PointT > &cloud, const Eigen::Vector4f &centroid, Eigen::Matrix3f &covariance_matrix)
	Compute the 3x3 covariance matrix of a given set of points. The result is returned as a Eigen::Matrix3f. Note: the covariance matrix is not normalized with the number of points. For a normalized covariance, please use computeNormalizedCovarianceMatrix.
template<typename PointT >
void	computeCovarianceMatrixNormalized (const pcl::PointCloud< PointT > &cloud, const pcl::PointIndices &indices, const Eigen::Vector4f &centroid, Eigen::Matrix3f &covariance_matrix)
	Compute the normalized 3x3 covariance matrix of a given set of points using their indices. The result is returned as a Eigen::Matrix3f. Normalized means that every entry has been divided by the number of entries in indices.
template<typename PointT >
void	computeCovarianceMatrixNormalized (const pcl::PointCloud< PointT > &cloud, const std::vector< int > &indices, const Eigen::Vector4f &centroid, Eigen::Matrix3f &covariance_matrix)
	Compute the normalized 3x3 covariance matrix of a given set of points using their indices. The result is returned as a Eigen::Matrix3f. Normalized means that every entry has been divided by the number of entries in indices.
template<typename PointT >
void	computeCovarianceMatrixNormalized (const pcl::PointCloud< PointT > &cloud, const Eigen::Vector4f &centroid, Eigen::Matrix3f &covariance_matrix)
	Compute normalized the 3x3 covariance matrix of a given set of points. The result is returned as a Eigen::Matrix3f. Normalized means that every entry has been divided by the number of points in the point cloud.
template<typename PointT >
void	computeNDCentroid (const pcl::PointCloud< PointT > &cloud, const pcl::PointIndices &indices, Eigen::VectorXf &centroid)
	General, all purpose nD centroid estimation for a set of points using their indices.
template<typename PointT >
void	computeNDCentroid (const pcl::PointCloud< PointT > &cloud, const std::vector< int > &indices, Eigen::VectorXf &centroid)
	General, all purpose nD centroid estimation for a set of points using their indices.
template<typename PointT >
void	computeNDCentroid (const pcl::PointCloud< PointT > &cloud, Eigen::VectorXf &centroid)
	General, all purpose nD centroid estimation for a set of points using their indices.
bool	computePairFeatures (const Eigen::Vector4f &p1, const Eigen::Vector4f &n1, const Eigen::Vector4f &p2, const Eigen::Vector4f &n2, float &f1, float &f2, float &f3, float &f4)
	Compute the 4-tuple representation containing the three angles and one distance between two points represented by Cartesian coordinates and normals.
template<typename PointT >
void	computePointNormal (const pcl::PointCloud< PointT > &cloud, const std::vector< int > &indices, Eigen::Vector4f &plane_parameters, float &curvature)
	Compute the Least-Squares plane fit for a given set of points, using their indices, and return the estimated plane parameters together with the surface curvature.
template<typename PointT >
void	computePointNormal (const pcl::PointCloud< PointT > &cloud, Eigen::Vector4f &plane_parameters, float &curvature)
	Compute the Least-Squares plane fit for a given set of points, and return the estimated plane parameters together with the surface curvature.
template<typename Matrix , typename Roots >
void	computeRoots (const Matrix &m, Roots &roots)
template<typename Scalar , typename Roots >
void	computeRoots2 (const Scalar &b, const Scalar &c, Roots &roots)
template<typename PointInT , typename PointNT , typename PointOutT >
void	computeRSD (const pcl::PointCloud< PointInT > &surface, const pcl::PointCloud< PointNT > &normals, const std::vector< int > &indices, double max_dist, int nr_subdiv, double plane_radius, PointOutT &radii)
	Estimate the Radius-based Surface Descriptor (RSD) for a given point based on its spatial neighborhood of 3D points with normals.
template<typename PointIn1T , typename PointIn2T , typename PointOutT >
void	concatenateFields (const pcl::PointCloud< PointIn1T > &cloud1_in, const pcl::PointCloud< PointIn2T > &cloud2_in, pcl::PointCloud< PointOutT > &cloud_out)
	Concatenate two datasets representing different fields.
bool	concatenatePointCloud (const sensor_msgs::PointCloud2 &cloud1, const sensor_msgs::PointCloud2 &cloud2, sensor_msgs::PointCloud2 &cloud_out)
	Concatenate two sensor_msgs::PointCloud2. Returns true if successful, false if failed (e.g., name/number of fields differs).
template<typename PointT >
void	copyPointCloud (const pcl::PointCloud< PointT > &cloud_in, const std::vector< pcl::PointIndices > &indices, pcl::PointCloud< PointT > &cloud_out)
	Extract the indices of a given point cloud as a new point cloud.
template<typename PointT >
void	copyPointCloud (const pcl::PointCloud< PointT > &cloud_in, const PointIndices &indices, pcl::PointCloud< PointT > &cloud_out)
	Extract the indices of a given point cloud as a new point cloud.
template<typename PointT >
void	copyPointCloud (const pcl::PointCloud< PointT > &cloud_in, const std::vector< int > &indices, pcl::PointCloud< PointT > &cloud_out)
	Extract the indices of a given point cloud as a new point cloud.
void	copyPointCloud (const sensor_msgs::PointCloud2 &cloud_in, const std::vector< int > &indices, sensor_msgs::PointCloud2 &cloud_out)
	Extract the indices of a given point cloud as a new point cloud.
template<typename PointInT , typename PointOutT >
void	copyPointCloud (const pcl::PointCloud< PointInT > &cloud_in, pcl::PointCloud< PointOutT > &cloud_out)
	Copy all the fields from a given point cloud into a new point cloud.
template<typename PointT >
void	createMapping (const std::vector< sensor_msgs::PointField > &msg_fields, MsgFieldMap &field_map)
float	CS_Norm (float A, float B, int dim)
	Compute the CS norm of the vector between two points.
double	deg2rad (double alpha)
	Convert an angle from degrees to radians.
float	deg2rad (float alpha)
	Convert an angle from degrees to radians.
template<typename PointT >
void	demeanPointCloud (const pcl::PointCloud< PointT > &cloud_in, const std::vector< int > &indices, const Eigen::Vector4f &centroid, Eigen::MatrixXf &cloud_out)
	Subtract a centroid from a point cloud and return the de-meaned representation as an Eigen matrix.
template<typename PointT >
void	demeanPointCloud (const pcl::PointCloud< PointT > &cloud_in, const Eigen::Vector4f &centroid, Eigen::MatrixXf &cloud_out)
	Subtract a centroid from a point cloud and return the de-meaned representation as an Eigen matrix.
template<typename PointT >
void	demeanPointCloud (const pcl::PointCloud< PointT > &cloud_in, const std::vector< int > &indices, const Eigen::Vector4f &centroid, pcl::PointCloud< PointT > &cloud_out)
	Subtract a centroid from a point cloud and return the de-meaned representation.
template<typename PointT >
void	demeanPointCloud (const pcl::PointCloud< PointT > &cloud_in, const Eigen::Vector4f &centroid, pcl::PointCloud< PointT > &cloud_out)
	Subtract a centroid from a point cloud and return the de-meaned representation.
float	Div_Norm (float A, float B, int dim)
	Compute the div norm of the vector between two points.
template<typename Matrix , typename Vector >
void	eigen33 (const Matrix &mat, Matrix &evecs, Vector &evals)
template<typename PointSource , typename PointTarget >
void	estimateRigidTransformationSVD (const pcl::PointCloud< PointSource > &cloud_src, const std::vector< int > &indices_src, const pcl::PointCloud< PointTarget > &cloud_tgt, const std::vector< int > &indices_tgt, Eigen::Matrix4f &transformation_matrix)
	Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
template<typename PointSource , typename PointTarget >
void	estimateRigidTransformationSVD (const pcl::PointCloud< PointSource > &cloud_src, const std::vector< int > &indices_src, const pcl::PointCloud< PointTarget > &cloud_tgt, Eigen::Matrix4f &transformation_matrix)
	Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
template<typename PointSource , typename PointTarget >
void	estimateRigidTransformationSVD (const pcl::PointCloud< PointSource > &cloud_src, const pcl::PointCloud< PointTarget > &cloud_tgt, Eigen::Matrix4f &transformation_matrix)
	Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
template<typename PointType1 , typename PointType2 >
float	euclideanDistance (const PointType1 &p1, const PointType2 &p2)
	Calculate the euclidean distance between the two given points.
template<typename PointT , typename Normal >
void	extractEuclideanClusters (const PointCloud< PointT > &cloud, const PointCloud< Normal > &normals, const std::vector< int > &indices, const boost::shared_ptr< KdTree< PointT > > &tree, float tolerance, std::vector< PointIndices > &clusters, double eps_angle, unsigned int min_pts_per_cluster=1, unsigned int max_pts_per_cluster=(std::numeric_limits< int >::max)())
	Decompose a region of space into clusters based on the euclidean distance between points, and the normal angular deviation.
template<typename PointT , typename Normal >
void	extractEuclideanClusters (const PointCloud< PointT > &cloud, const PointCloud< Normal > &normals, float tolerance, const boost::shared_ptr< KdTree< PointT > > &tree, std::vector< PointIndices > &clusters, double eps_angle, unsigned int min_pts_per_cluster=1, unsigned int max_pts_per_cluster=(std::numeric_limits< int >::max)())
	Decompose a region of space into clusters based on the euclidean distance between points, and the normal angular deviation.
template<typename PointT >
void	extractEuclideanClusters (const PointCloud< PointT > &cloud, const std::vector< int > &indices, const boost::shared_ptr< KdTree< PointT > > &tree, float tolerance, std::vector< PointIndices > &clusters, unsigned int min_pts_per_cluster=1, unsigned int max_pts_per_cluster=(std::numeric_limits< int >::max)())
	Decompose a region of space into clusters based on the Euclidean distance between points.
template<typename PointT >
void	extractEuclideanClusters (const PointCloud< PointT > &cloud, const boost::shared_ptr< KdTree< PointT > > &tree, float tolerance, std::vector< PointIndices > &clusters, unsigned int min_pts_per_cluster=1, unsigned int max_pts_per_cluster=(std::numeric_limits< int >::max)())
	Decompose a region of space into clusters based on the Euclidean distance between points.
template<typename PointT >
void	flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z, float &nx, float &ny, float &nz)
	Flip (in place) the estimated normal of a point towards a given viewpoint.
template<typename PointT >
void	flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z, Eigen::Vector4f &normal)
	Flip (in place) the estimated normal of a point towards a given viewpoint.
template<typename Sequence , typename F >
void	for_each_type (F f)
template<typename PointT >
void	fromROSMsg (const sensor_msgs::PointCloud2 &msg, pcl::PointCloud< PointT > &cloud)
template<typename PointT >
void	fromROSMsg (const sensor_msgs::PointCloud2 &msg, pcl::PointCloud< PointT > &cloud, const MsgFieldMap &field_map)
void	getAllPcdFilesInDirectory (const std::string &directory, std::vector< std::string > &file_names)
	Find all *.pcd files in the directory and return them sorted.
float	getAngle2D (const float point[2])
	Compute the angle in the [ 0, 2*PI ) interval of a point (direction) with a reference (0, 0) in 2D.
double	getAngle3D (const Eigen::Vector4f &v1, const Eigen::Vector4f &v2)
	Compute the smallest angle between two vectors in the [ 0, PI ) interval in 3D.
template<typename PointT >
double	getCircumcircleRadius (const PointT &pa, const PointT &pb, const PointT &pc)
	Compute the radius of a circumscribed circle for a triangle formed of three points pa, pb, and pc.
bool	getEigenAsPointCloud (Eigen::MatrixXf &in, sensor_msgs::PointCloud2 &out)
	Copy the XYZ dimensions from an Eigen MatrixXf into a sensor_msgs::PointCloud2 message.
void	getEulerAngles (const Eigen::Affine3f &t, float &roll, float &pitch, float &yaw)
	Extract the Euler angles (XYZ-convention) from the given transformation.
template<typename PointT >
int	getFieldIndex (const pcl::PointCloud< PointT > &cloud, const std::string &field_name, std::vector< sensor_msgs::PointField > &fields)
	Get the index of a specified field (i.e., dimension/channel).
int	getFieldIndex (const sensor_msgs::PointCloud2 &cloud, const std::string &field_name)
	Get the index of a specified field (i.e., dimension/channel).
template<typename PointT >
void	getFields (const pcl::PointCloud< PointT > &cloud, std::vector< sensor_msgs::PointField > &fields)
	Get the list of available fields (i.e., dimension/channel).
int	getFieldSize (int datatype)
	Obtains the size of a specific field data type in bytes.
std::string	getFieldsList (const sensor_msgs::PointCloud2 &cloud)
	Get the available point cloud fields as a space separated string.
template<typename PointT >
std::string	getFieldsList (const pcl::PointCloud< PointT > &cloud)
	Get the list of all fields available in a given cloud.
char	getFieldType (int type)
	Obtains the type of the PointField from a specific PointField as a char.
int	getFieldType (int size, char type)
	Obtains the type of the PointField from a specific size and type.
std::string	getFileExtension (const std::string &input)
	Get the file extension from the given string (the remaining string after the last '.').
std::string	getFilenameWithoutExtension (const std::string &input)
	Remove the extension from the given string and return only the filename (everything before the last '.').
std::string	getFilenameWithoutPath (const std::string &input)
	Remove the path from the given string and return only the filename (the remaining string after the last '/').
Eigen::Affine3f	getInverse (const Eigen::Affine3f &transformation)
	Get the inverse of an Eigen::Affine3f object.
void	getInverse (const Eigen::Affine3f &transformation, Eigen::Affine3f &inverse_transformation)
	Get the inverse of an Eigen::Affine3f object.
template<typename PointT >
void	getMaxDistance (const pcl::PointCloud< PointT > &cloud, const std::vector< int > &indices, const Eigen::Vector4f &pivot_pt, Eigen::Vector4f &max_pt)
	Get the point at maximum distance from a given point and a given pointcloud.
template<typename PointT >
void	getMaxDistance (const pcl::PointCloud< PointT > &cloud, const Eigen::Vector4f &pivot_pt, Eigen::Vector4f &max_pt)
	Get the point at maximum distance from a given point and a given pointcloud.
void	getMeanStd (const std::vector< float > &values, double &mean, double &stddev)
	Compute both the mean and the standard deviation of an array of values.
void	getMeanStdDev (const std::vector< float > &values, double &mean, double &stddev)
	Compute both the mean and the standard deviation of an array of values.
void	getMinMax (const sensor_msgs::PointCloud2 &cloud, int idx, const std::string &field_name, float &min_p, float &max_p)
	Get the minimum and maximum values on a point histogram.
template<typename PointT >
void	getMinMax (const PointT &histogram, int len, float &min_p, float &max_p)
	Get the minimum and maximum values on a point histogram.
template<typename PointT >
void	getMinMax3D (const typename pcl::PointCloud< PointT >::ConstPtr &cloud, const std::string &distance_field_name, float min_distance, float max_distance, Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt, bool limit_negative=false)
	Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud, without considering points outside of a distance threshold from the laser origin.
void	getMinMax3D (const sensor_msgs::PointCloud2ConstPtr &cloud, int x_idx, int y_idx, int z_idx, const std::string &distance_field_name, float min_distance, float max_distance, Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt, bool limit_negative=false)
void	getMinMax3D (const sensor_msgs::PointCloud2ConstPtr &cloud, int x_idx, int y_idx, int z_idx, Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt)
template<typename PointT >
void	getMinMax3D (const pcl::PointCloud< PointT > &cloud, const pcl::PointIndices &indices, Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt)
	Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud.
template<typename PointT >
void	getMinMax3D (const pcl::PointCloud< PointT > &cloud, const std::vector< int > &indices, Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt)
	Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud.
template<typename PointT >
void	getMinMax3D (const pcl::PointCloud< PointT > &cloud, Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt)
	Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud.
template<typename PointT >
void	getMinMax3D (const pcl::PointCloud< PointT > &cloud, PointT &min_pt, PointT &max_pt)
	Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud.
bool	getPointCloudAsEigen (const sensor_msgs::PointCloud2 &in, Eigen::MatrixXf &out)
	Copy the XYZ dimensions of a sensor_msgs::PointCloud2 into Eigen format.
template<typename PointT >
void	getPointCloudDifference (const pcl::PointCloud< PointT > &src, const pcl::PointCloud< PointT > &tgt, double threshold, const boost::shared_ptr< pcl::KdTree< PointT > > &tree, pcl::PointCloud< PointT > &output)
	Obtain the difference between two aligned point clouds as another point cloud, given a distance threshold.
template<typename PointT >
void	getPointsInBox (const pcl::PointCloud< PointT > &cloud, Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt, std::vector< int > &indices)
	Get a set of points residing in a box given its bounds.
Eigen::Affine3f	getRotation (const Eigen::Affine3f &transformation)
	Get only the rotation part of the transformation.
Eigen::Affine3f	getRotationOnly (const Eigen::Affine3f &transformation)
double	getTime ()
Eigen::Affine3f	getTransformation (float x, float y, float z, float roll, float pitch, float yaw)
	Create a transformation from the given translation and Euler angles (XYZ-convention).
void	getTransformation (float x, float y, float z, float roll, float pitch, float yaw, Eigen::Affine3f &t)
	Create a transformation from the given translation and Euler angles (XYZ-convention).
Eigen::Affine3f	getTransformationFromTwoUnitVectors (const Eigen::Vector3f &y_direction, const Eigen::Vector3f &z_axis)
void	getTransformationFromTwoUnitVectors (const Eigen::Vector3f &y_direction, const Eigen::Vector3f &z_axis, Eigen::Affine3f &transformation)
void	getTransformationFromTwoUnitVectorsAndOrigin (const Eigen::Vector3f &y_direction, const Eigen::Vector3f &z_axis, const Eigen::Vector3f &origin, Eigen::Affine3f &transformation)
	Get the transformation that will translate orign to (0,0,0) and rotate z_axis into (0,0,1) and y_direction into a vector with x=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).
template<typename PointCloudType >
void	getTransformedPointCloud (const PointCloudType &input, const Eigen::Affine3f &transformation, PointCloudType &output)
	Transform each point in the given point cloud according to the given transformation.
Eigen::Affine3f	getTransFromUnitVectorsXY (const Eigen::Vector3f &x_axis, const Eigen::Vector3f &y_direction)
	Get the unique 3D rotation that will rotate x_axis into (1,0,0) and y_direction into a vector with z=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).
void	getTransFromUnitVectorsXY (const Eigen::Vector3f &x_axis, const Eigen::Vector3f &y_direction, Eigen::Affine3f &transformation)
	Get the unique 3D rotation that will rotate x_axis into (1,0,0) and y_direction into a vector with z=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).
Eigen::Affine3f	getTransFromUnitVectorsZY (const Eigen::Vector3f &z_axis, const Eigen::Vector3f &y_direction)
	Get the unique 3D rotation that will rotate z_axis into (0,0,1) and y_direction into a vector with x=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).
void	getTransFromUnitVectorsZY (const Eigen::Vector3f &z_axis, const Eigen::Vector3f &y_direction, Eigen::Affine3f &transformation)
	Get the unique 3D rotation that will rotate z_axis into (0,0,1) and y_direction into a vector with x=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).
Eigen::Vector3f	getTranslation (const Eigen::Affine3f &transformation)
	Get only the translation part of the transformation.
void	getTranslationAndEulerAngles (const Eigen::Affine3f &t, float &x, float &y, float &z, float &roll, float &pitch, float &yaw)
template<typename PointType >
bool	hasValidXYZ (const PointType &p)
	Checks if x,y,z are finite numbers.
float	HIK_Norm (float A, float B, int dim)
	Compute the HIK norm of the vector between two points.
template<typename PointT >
void	initTree (const int &spatial_locator, boost::shared_ptr< pcl::KdTree< PointT > > &tree, int k=0)
	Initialize the spatial locator used for nearest neighbor search.
bool	isBetterCorrespondence (const PointCorrespondence &pc1, const PointCorrespondence &pc2)
	Comparator to enable us to sort a vector of PointCorrespondences according to their scores using std::sort(begin(), end(), isBetterCorrespondence);.
template<typename PointT >
bool	isPointIn2DPolygon (const PointT &point, const pcl::PointCloud< PointT > &polygon)
	General purpose method for checking if a 3D point is inside or outside a given 2D polygon.
template<typename PointT >
bool	isXYPointIn2DXYPolygon (const PointT &point, const pcl::PointCloud< PointT > &polygon)
	Check if a 2d point (X and Y coordinates considered only!) is inside or outside a given polygon. This method assumes that both the point and the polygon are projected onto the XY plane.
float	JM_Norm (float A, float B, int dim)
	Compute the JM norm of the vector between two points.
float	K_Norm (float A, float B, int dim, float P1, float P2)
	Compute the K norm of the vector between two points.
float	KL_Norm (float A, float B, int dim)
	Compute the KL between two discrete probability density functions.
float	L1_Norm (float A, float B, int dim)
	Compute the L1 norm of the vector between two points.
float	L2_Norm (float A, float B, int dim)
	Compute the L2 norm of the vector between two points.
float	L2_Norm_SQR (float A, float B, int dim)
	Compute the squared L2 norm of the vector between two points.
void	lineToLineSegment (const Eigen::VectorXf &line_a, const Eigen::VectorXf &line_b, Eigen::Vector4f &pt1_seg, Eigen::Vector4f &pt2_seg)
	Get the shortest 3D segment between two 3D lines.
bool	lineWithLineIntersection (const pcl::ModelCoefficients &line_a, const pcl::ModelCoefficients &line_b, Eigen::Vector4f &point, double sqr_eps=1e-4)
	Get the intersection of a two 3D lines in space as a 3D point.
bool	lineWithLineIntersection (const Eigen::VectorXf &line_a, const Eigen::VectorXf &line_b, Eigen::Vector4f &point, double sqr_eps=1e-4)
	Get the intersection of a two 3D lines in space as a 3D point.
float	Linf_Norm (float A, float B, int dim)
	Compute the L-infinity norm of the vector between two points.
template<typename Derived >
void	loadBinary (Eigen::MatrixBase< Derived > &matrix, std::istream &file)
	Read a matrix from an input stream.
template<typename real >
real	normAngle (real alpha)
	Normalize an angle to (-PI, PI].
std::ostream &	operator<< (std::ostream &os, const RangeImageBorderExtractor::Parameters &p)
template<typename ContainerAllocator >
std::ostream &	operator<< (std::ostream &s, const ::pcl::Vertices_< ContainerAllocator > &v)
template<typename ContainerAllocator >
std::ostream &	operator<< (std::ostream &s, const ::pcl::PolygonMesh_< ContainerAllocator > &v)
template<typename ContainerAllocator >
std::ostream &	operator<< (std::ostream &s, const ::pcl::PointIndices_< ContainerAllocator > &v)
template<typename ContainerAllocator >
std::ostream &	operator<< (std::ostream &s, const ::pcl::ModelCoefficients_< ContainerAllocator > &v)
std::ostream &	operator<< (std::ostream &os, const RangeImage &r)
template<typename PointT >
std::ostream &	operator<< (std::ostream &s, const pcl::PointCloud< PointT > &p)
std::ostream &	operator<< (std::ostream &os, const NarfKeypoint::Parameters &p)
std::ostream &	operator<< (std::ostream &os, const PointSurfel &p)
std::ostream &	operator<< (std::ostream &os, const PointWithScale &p)
template<int N>
std::ostream &	operator<< (std::ostream &os, const Histogram< N > &p)
std::ostream &	operator<< (std::ostream &os, const IntensityGradient &p)
std::ostream &	operator<< (std::ostream &os, const BorderDescription &p)
std::ostream &	operator<< (std::ostream &os, const Narf36 &p)
std::ostream &	operator<< (std::ostream &os, const VFHSignature308 &p)
std::ostream &	operator<< (std::ostream &os, const FPFHSignature33 &p)
std::ostream &	operator<< (std::ostream &os, const PFHSignature125 &p)
std::ostream &	operator<< (std::ostream &os, const PrincipalCurvatures &p)
std::ostream &	operator<< (std::ostream &os, const Boundary &p)
std::ostream &	operator<< (std::ostream &os, const PrincipalRadiiRSD &p)
std::ostream &	operator<< (std::ostream &os, const MomentInvariants &p)
std::ostream &	operator<< (std::ostream &os, const PointWithViewpoint &p)
std::ostream &	operator<< (std::ostream &os, const PointWithRange &p)
std::ostream &	operator<< (std::ostream &os, const PointXYZINormal &p)
std::ostream &	operator<< (std::ostream &os, const PointXYZRGBNormal &p)
std::ostream &	operator<< (std::ostream &os, const PointNormal &p)
std::ostream &	operator<< (std::ostream &os, const Normal &p)
std::ostream &	operator<< (std::ostream &os, const InterestPoint &p)
std::ostream &	operator<< (std::ostream &os, const PointXY &p)
std::ostream &	operator<< (std::ostream &os, const PointXYZRGB &p)
std::ostream &	operator<< (std::ostream &os, const PointXYZRGBA &p)
std::ostream &	operator<< (std::ostream &os, const PointXYZI &p)
std::ostream &	operator<< (std::ostream &os, const PointXYZ &p)
std::ostream &	operator<< (std::ostream &os, const Eigen::Affine3f &m)
	Output operator for Tranform3f.
template<typename real >
std::ostream &	operator<< (std::ostream &os, const BivariatePolynomialT< real > &p)
float	PF_Norm (float A, float B, int dim, float P1, float P2)
	Compute the PF norm of the vector between two points.
template<typename Point >
double	pointToPlaneDistance (const Point &p, const Eigen::Vector4f &plane_coefficients)
	Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0.
template<typename Point >
double	pointToPlaneDistance (const Point &p, double a, double b, double c, double d)
	Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0.
template<typename Point >
double	pointToPlaneDistanceSigned (const Point &p, const Eigen::Vector4f &plane_coefficients)
	Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0.
template<typename Point >
double	pointToPlaneDistanceSigned (const Point &p, double a, double b, double c, double d)
	Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0.
double	rad2deg (double alpha)
	Convert an angle from radians to degrees.
float	rad2deg (float alpha)
	Convert an angle from radians to degrees.
template<typename PointT >
void	removeNaNFromPointCloud (const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, std::vector< int > &index)
	Removes points with x, y, or z equal to NaN.
static const std::map < pcl::SacModel, unsigned int >	SAC_SAMPLE_SIZE (sample_size_pairs, sample_size_pairs+sizeof(sample_size_pairs)/sizeof(SampleSizeModel))
template<typename Derived >
void	saveBinary (const Eigen::MatrixBase< Derived > &matrix, std::ostream &file)
	Write a matrix to an output stream.
void	solvePlaneParameters (const Eigen::Matrix3f &covariance_matrix, float &nx, float &ny, float &nz, float &curvature)
	Solve the eigenvalues and eigenvectors of a given 3x3 covariance matrix, and estimate the least-squares plane normal and surface curvature.
void	solvePlaneParameters (const Eigen::Matrix3f &covariance_matrix, const Eigen::Vector4f &point, Eigen::Vector4f &plane_parameters, float &curvature)
	Solve the eigenvalues and eigenvectors of a given 3x3 covariance matrix, and estimate the least-squares plane normal and surface curvature.
double	sqrPointToLineDistance (const Eigen::Vector4f &pt, const Eigen::Vector4f &line_pt, const Eigen::Vector4f &line_dir, const double sqr_length)
	Get the square distance from a point to a line (represented by a point and a direction).
double	sqrPointToLineDistance (const Eigen::Vector4f &pt, const Eigen::Vector4f &line_pt, const Eigen::Vector4f &line_dir)
	Get the square distance from a point to a line (represented by a point and a direction).
template<typename PointType1 , typename PointType2 >
float	squaredEuclideanDistance (const PointType1 &p1, const PointType2 &p2)
	Calculate the squared euclidean distance between the two given points.
float	Sublinear_Norm (float A, float B, int dim)
	Compute the sublinear norm of the vector between two points.
void	toROSMsg (const sensor_msgs::PointCloud2 &cloud, sensor_msgs::Image &msg)
	Copy the RGB fields of a PointCloud2 msg into sensor_msgs::Image format.
template<typename CloudT >
void	toROSMsg (const CloudT &cloud, sensor_msgs::Image &msg)
	Copy the RGB fields of a PointCloud into sensor_msgs::Image format.
template<typename PointT >
void	toROSMsg (const pcl::PointCloud< PointT > &cloud, sensor_msgs::PointCloud2 &msg)
template<typename PointT >
void	transformPointCloud (const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, const Eigen::Vector3f &offset, const Eigen::Quaternionf &rotation)
	Apply a rigid transform defined by a 3D offset and a quaternion.
template<typename PointT >
void	transformPointCloud (const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, const Eigen::Matrix4f &transform)
	Apply an affine transform defined by an Eigen Transform.
template<typename PointT >
void	transformPointCloud (const pcl::PointCloud< PointT > &cloud_in, const std::vector< int > &indices, pcl::PointCloud< PointT > &cloud_out, const Eigen::Affine3f &transform)
	Apply an affine transform defined by an Eigen Transform.
template<typename PointT >
void	transformPointCloud (const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, const Eigen::Affine3f &transform)
	Apply an affine transform defined by an Eigen Transform.
template<typename PointT >
void	transformPointCloudWithNormals (const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, const Eigen::Vector3f &offset, const Eigen::Quaternionf &rotation)
	Transform a point cloud and rotate its normals using an Eigen transform.
template<typename PointT >
void	transformPointCloudWithNormals (const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, const Eigen::Matrix4f &transform)
	Transform a point cloud and rotate its normals using an Eigen transform.
template<typename PointT >
void	transformPointCloudWithNormals (const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, const Eigen::Affine3f &transform)
	Transform a point cloud and rotate its normals using an Eigen transform.
template<typename PointType >
PointType	transformXYZ (const Eigen::Affine3f &transformation, const PointType &point)
	Transform a point with members x,y,z.
Variables
struct pcl::PointXYZI	EIGEN_ALIGN16
const int	I_SHIFT_EDGE [3][2]
const int	I_SHIFT_EP [12][2]
	The 12 edges of a cell.
const int	I_SHIFT_PT [4]
static const int	KDTREE_FLANN = 0
static const int	KDTREE_ORGANIZED_INDEX = 1
static const int	SAC_LMEDS = 1
static const int	SAC_MLESAC = 5
static const int	SAC_MSAC = 2
static const int	SAC_RANSAC = 0
static const int	SAC_RMSAC = 4
static const int	SAC_RRANSAC = 3

Detailed Description

Author:: Bastian Steder; Patrick Mihelich

Point Cloud conversions to/from sensor_msgs::PointCloud2.

Author:: Patrick Mihelich

Helper class.

Author:: Patrick Mihelich

Point traits.

Typedef Documentation

typedef Eigen::Map<Eigen::Array3f> pcl::Array3fMap

Definition at line 125 of file point_types.hpp.

typedef const Eigen::Map<const Eigen::Array3f> pcl::Array3fMapConst

Definition at line 126 of file point_types.hpp.

typedef Eigen::Map<Eigen::Array4f, Eigen::Aligned> pcl::Array4fMap

Definition at line 127 of file point_types.hpp.

typedef const Eigen::Map<const Eigen::Array4f, Eigen::Aligned> pcl::Array4fMapConst

Definition at line 128 of file point_types.hpp.

typedef BivariatePolynomialT<float> pcl::BivariatePolynomial

Definition at line 88 of file bivariate_polynomial.h.

typedef BivariatePolynomialT<double> pcl::BivariatePolynomiald

Definition at line 87 of file bivariate_polynomial.h.

typedef std::bitset<32> pcl::BorderTraits

Data type to store extended information about a transition from foreground to backgroundSpecification of the fields for BorderDescription::traits.

Definition at line 128 of file point_types.h.

typedef boost::shared_ptr<const std::vector<int> > pcl::IndicesConstPtr

Definition at line 62 of file pcl_base.h.

typedef boost::shared_ptr<std::vector<int> > pcl::IndicesPtr

Definition at line 61 of file pcl_base.h.

typedef::pcl::ModelCoefficients_< std::allocator< void > > pcl::ModelCoefficients

Definition at line 39 of file headers/ModelCoefficients.h.

typedef boost::shared_ptr<::pcl::ModelCoefficients const > pcl::ModelCoefficientsConstPtr

Definition at line 42 of file headers/ModelCoefficients.h.

typedef boost::shared_ptr<::pcl::ModelCoefficients > pcl::ModelCoefficientsPtr

Definition at line 41 of file headers/ModelCoefficients.h.

typedef std::vector<detail::FieldMapping> pcl::MsgFieldMap

Definition at line 59 of file point_cloud.h.

typedef std::vector<PointCorrespondence3D, Eigen::aligned_allocator<PointCorrespondence3D> > pcl::PointCorrespondences3DVector

Definition at line 72 of file point_correspondence.h.

typedef std::vector<PointCorrespondence6D, Eigen::aligned_allocator<PointCorrespondence6D> > pcl::PointCorrespondences6DVector

Definition at line 86 of file point_correspondence.h.

typedef::pcl::PointIndices_< std::allocator< void > > pcl::PointIndices

Definition at line 39 of file headers/PointIndices.h.

typedef boost::shared_ptr<::pcl::PointIndices const > pcl::PointIndicesConstPtr

Definition at line 42 of file headers/PointIndices.h.

typedef boost::shared_ptr<::pcl::PointIndices > pcl::PointIndicesPtr

Definition at line 41 of file headers/PointIndices.h.

typedef::pcl::PolygonMesh_< std::allocator< void > > pcl::PolygonMesh

Definition at line 46 of file headers/PolygonMesh.h.

typedef boost::shared_ptr<::pcl::PolygonMesh const > pcl::PolygonMeshConstPtr

Definition at line 49 of file headers/PolygonMesh.h.

typedef boost::shared_ptr<::pcl::PolygonMesh > pcl::PolygonMeshPtr

Definition at line 48 of file headers/PolygonMesh.h.

typedef PolynomialCalculationsT<float> pcl::PolynomialCalculations

Definition at line 86 of file polynomial_calculations.h.

typedef PolynomialCalculationsT<double> pcl::PolynomialCalculationsd

Definition at line 85 of file polynomial_calculations.h.

typedef Eigen::Map<Eigen::Vector3f> pcl::Vector3fMap

Definition at line 129 of file point_types.hpp.

typedef const Eigen::Map<const Eigen::Vector3f> pcl::Vector3fMapConst

Definition at line 130 of file point_types.hpp.

typedef Eigen::Map<Eigen::Vector4f, Eigen::Aligned> pcl::Vector4fMap

Definition at line 131 of file point_types.hpp.

typedef const Eigen::Map<const Eigen::Vector4f, Eigen::Aligned> pcl::Vector4fMapConst

Definition at line 132 of file point_types.hpp.

typedef VectorAverage<float, 2> pcl::VectorAverage2f

Definition at line 109 of file vector_average.h.

typedef VectorAverage<float, 3> pcl::VectorAverage3f

Definition at line 110 of file vector_average.h.

typedef VectorAverage<float, 4> pcl::VectorAverage4f

Definition at line 111 of file vector_average.h.

typedef::pcl::Vertices_< std::allocator< void > > pcl::Vertices

Definition at line 31 of file headers/Vertices.h.

typedef boost::shared_ptr<::pcl::Vertices const > pcl::VerticesConstPtr

Definition at line 34 of file headers/Vertices.h.

typedef boost::shared_ptr<::pcl::Vertices > pcl::VerticesPtr

Definition at line 33 of file headers/Vertices.h.

Enumeration Type Documentation

enum pcl::BorderTrait

Specification of the fields for BorderDescription::traits.

Enumerator:

BORDER_TRAIT__OBSTACLE_BORDER
BORDER_TRAIT__SHADOW_BORDER
BORDER_TRAIT__VEIL_POINT
BORDER_TRAIT__SHADOW_BORDER_TOP
BORDER_TRAIT__SHADOW_BORDER_RIGHT
BORDER_TRAIT__SHADOW_BORDER_BOTTOM
BORDER_TRAIT__SHADOW_BORDER_LEFT
BORDER_TRAIT__OBSTACLE_BORDER_TOP
BORDER_TRAIT__OBSTACLE_BORDER_RIGHT
BORDER_TRAIT__OBSTACLE_BORDER_BOTTOM
BORDER_TRAIT__OBSTACLE_BORDER_LEFT
BORDER_TRAIT__VEIL_POINT_TOP
BORDER_TRAIT__VEIL_POINT_RIGHT
BORDER_TRAIT__VEIL_POINT_BOTTOM
BORDER_TRAIT__VEIL_POINT_LEFT

Definition at line 136 of file point_types.h.

enum pcl::SacModel

Enumerator:

SACMODEL_PLANE
SACMODEL_LINE
SACMODEL_CIRCLE2D
SACMODEL_CIRCLE3D
SACMODEL_SPHERE
SACMODEL_CYLINDER
SACMODEL_CONE
SACMODEL_TORUS
SACMODEL_PARALLEL_LINE
SACMODEL_PERPENDICULAR_PLANE
SACMODEL_PARALLEL_LINES
SACMODEL_NORMAL_PLANE
SACMODEL_REGISTRATION
SACMODEL_PARALLEL_PLANE
SACMODEL_NORMAL_PARALLEL_PLANE

Definition at line 45 of file model_types.h.

Function Documentation

float pcl::B_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the B norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 89 of file norms.hpp.

bool pcl::comparePointClusters	(	const pcl::PointIndices &	a,
		const pcl::PointIndices &	b
	)			`[inline]`

Sort clusters method (for std::sort).

Definition at line 376 of file extract_clusters.h.

bool pcl::comparePoints2D	(	const std::pair< int, Eigen::Vector4f > &	p1,
		const std::pair< int, Eigen::Vector4f > &	p2
	)			`[inline]`

Sort 2D points in a vector structure.

Parameters:

	p1	the first point
	p2	the second point

Definition at line 75 of file convex_hull.h.

template<typename PointT >

void pcl::compute3DCentroid	(	const pcl::PointCloud< PointT > &	cloud,
		const pcl::PointIndices &	indices,
		Eigen::Vector4f &	centroid
	)			`[inline]`

Compute the 3D (X-Y-Z) centroid of a set of points using their indices and return it as a 3D vector.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	centroid	the output centroid

Definition at line 117 of file feature.hpp.

template<typename PointT >

void pcl::compute3DCentroid	(	const pcl::PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		Eigen::Vector4f &	centroid
	)			`[inline]`

Compute the 3D (X-Y-Z) centroid of a set of points using their indices and return it as a 3D vector.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	centroid	the output centroid

Definition at line 78 of file feature.hpp.

template<typename PointT >

void pcl::compute3DCentroid	(	const pcl::PointCloud< PointT > &	cloud,
		Eigen::Vector4f &	centroid
	)			`[inline]`

Compute the 3D (X-Y-Z) centroid of a set of points and return it as a 3D vector.

Parameters:

	cloud	the input point cloud
	centroid	the output centroid

Definition at line 40 of file feature.hpp.

template<typename PointT >

void pcl::computeCovarianceMatrix	(	const pcl::PointCloud< PointT > &	cloud,
		const pcl::PointIndices &	indices,
		const Eigen::Vector4f &	centroid,
		Eigen::Matrix3f &	covariance_matrix
	)			`[inline]`

Compute the 3x3 covariance matrix of a given set of points using their indices. The result is returned as a Eigen::Matrix3f. Note: the covariance matrix is not normalized with the number of points. For a normalized covariance, please use computeNormalizedCovarianceMatrix.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	centroid	the centroid of the set of points in the cloud
	covariance_matrix	the resultant 3x3 covariance matrix

Definition at line 307 of file feature.hpp.

template<typename PointT >

void pcl::computeCovarianceMatrix	(	const pcl::PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		const Eigen::Vector4f &	centroid,
		Eigen::Matrix3f &	covariance_matrix
	)			`[inline]`

Compute the 3x3 covariance matrix of a given set of points using their indices. The result is returned as a Eigen::Matrix3f. Note: the covariance matrix is not normalized with the number of points. For a normalized covariance, please use computeNormalizedCovarianceMatrix.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	centroid	the centroid of the set of points in the cloud
	covariance_matrix	the resultant 3x3 covariance matrix

Definition at line 246 of file feature.hpp.

template<typename PointT >

void pcl::computeCovarianceMatrix	(	const pcl::PointCloud< PointT > &	cloud,
		const Eigen::Vector4f &	centroid,
		Eigen::Matrix3f &	covariance_matrix
	)			`[inline]`

Compute the 3x3 covariance matrix of a given set of points. The result is returned as a Eigen::Matrix3f. Note: the covariance matrix is not normalized with the number of points. For a normalized covariance, please use computeNormalizedCovarianceMatrix.

Parameters:

	cloud	the input point cloud
	centroid	the centroid of the set of points in the cloud
	covariance_matrix	the resultant 3x3 covariance matrix

Definition at line 176 of file feature.hpp.

template<typename PointT >

void pcl::computeCovarianceMatrixNormalized	(	const pcl::PointCloud< PointT > &	cloud,
		const pcl::PointIndices &	indices,
		const Eigen::Vector4f &	centroid,
		Eigen::Matrix3f &	covariance_matrix
	)			`[inline]`

Compute the normalized 3x3 covariance matrix of a given set of points using their indices. The result is returned as a Eigen::Matrix3f. Normalized means that every entry has been divided by the number of entries in indices.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	centroid	the centroid of the set of points in the cloud
	covariance_matrix	the resultant 3x3 covariance matrix

Definition at line 328 of file feature.hpp.

template<typename PointT >

void pcl::computeCovarianceMatrixNormalized	(	const pcl::PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		const Eigen::Vector4f &	centroid,
		Eigen::Matrix3f &	covariance_matrix
	)			`[inline]`

Compute the normalized 3x3 covariance matrix of a given set of points using their indices. The result is returned as a Eigen::Matrix3f. Normalized means that every entry has been divided by the number of entries in indices.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	centroid	the centroid of the set of points in the cloud
	covariance_matrix	the resultant 3x3 covariance matrix

Definition at line 317 of file feature.hpp.

template<typename PointT >

void pcl::computeCovarianceMatrixNormalized	(	const pcl::PointCloud< PointT > &	cloud,
		const Eigen::Vector4f &	centroid,
		Eigen::Matrix3f &	covariance_matrix
	)			`[inline]`

Compute normalized the 3x3 covariance matrix of a given set of points. The result is returned as a Eigen::Matrix3f. Normalized means that every entry has been divided by the number of points in the point cloud.

Parameters:

	cloud	the input point cloud
	centroid	the centroid of the set of points in the cloud
	covariance_matrix	the resultant 3x3 covariance matrix

Definition at line 236 of file feature.hpp.

template<typename PointT >

void pcl::computeNDCentroid	(	const pcl::PointCloud< PointT > &	cloud,
		const pcl::PointIndices &	indices,
		Eigen::VectorXf &	centroid
	)			`[inline]`

General, all purpose nD centroid estimation for a set of points using their indices.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	centroid	the output centroid

Definition at line 168 of file feature.hpp.

template<typename PointT >

void pcl::computeNDCentroid	(	const pcl::PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		Eigen::VectorXf &	centroid
	)			`[inline]`

General, all purpose nD centroid estimation for a set of points using their indices.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	centroid	the output centroid

Definition at line 146 of file feature.hpp.

template<typename PointT >

void pcl::computeNDCentroid	(	const pcl::PointCloud< PointT > &	cloud,
		Eigen::VectorXf &	centroid
	)			`[inline]`

General, all purpose nD centroid estimation for a set of points using their indices.

Parameters:

	cloud	the input point cloud
	centroid	the output centroid

Definition at line 125 of file feature.hpp.

bool pcl::computePairFeatures	(	const Eigen::Vector4f &	p1,
		const Eigen::Vector4f &	n1,
		const Eigen::Vector4f &	p2,
		const Eigen::Vector4f &	n2,
		float &	f1,
		float &	f2,
		float &	f3,
		float &	f4
	)

Compute the 4-tuple representation containing the three angles and one distance between two points represented by Cartesian coordinates and normals.

Note:: For explanations about the features, please see the literature mentioned above (the order of the features might be different).

Parameters:

	p1	the first XYZ point
	n1	the first surface normal
	p2	the second XYZ point
	n2	the second surface normal
	f1	the first angular feature (angle between the projection of nq_idx and u)
	f2	the second angular feature (angle between nq_idx and v)
	f3	the third angular feature (angle between np_idx and \|p_idx - q_idx\|)
	f4	the distance feature (p_idx - q_idx)

Definition at line 45 of file pfh.cpp.

template<typename PointT >

void pcl::computePointNormal	(	const pcl::PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		Eigen::Vector4f &	plane_parameters,
		float &	curvature
	)			`[inline]`

Compute the Least-Squares plane fit for a given set of points, using their indices, and return the estimated plane parameters together with the surface curvature.

Parameters:

	cloud	the input point cloud
	indices	the point cloud indices that need to be used
	plane_parameters	the plane parameters as: a, b, c, d (ax + by + cz + d = 0)
	curvature	the estimated surface curvature as a measure of $\lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)$

Definition at line 90 of file normal_3d.h.

template<typename PointT >

void pcl::computePointNormal	(	const pcl::PointCloud< PointT > &	cloud,
		Eigen::Vector4f &	plane_parameters,
		float &	curvature
	)			`[inline]`

Compute the Least-Squares plane fit for a given set of points, and return the estimated plane parameters together with the surface curvature.

Parameters:

cloud

the input point cloud

plane_parameters

the plane parameters as: a, b, c, d (ax + by + cz + d = 0)

curvature

the estimated surface curvature as a measure of

$\lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)$

Definition at line 55 of file normal_3d.h.

template<typename Matrix , typename Roots >

void pcl::computeRoots	(	const Matrix &	m,
		Roots &	roots
	)			`[inline]`

Definition at line 113 of file eigen.h.

template<typename Scalar , typename Roots >

void pcl::computeRoots2	(	const Scalar &	b,
		const Scalar &	c,
		Roots &	roots
	)			`[inline]`

Definition at line 99 of file eigen.h.

template<typename PointInT , typename PointNT , typename PointOutT >

void pcl::computeRSD	(	const pcl::PointCloud< PointInT > &	surface,
		const pcl::PointCloud< PointNT > &	normals,
		const std::vector< int > &	indices,
		double	max_dist,
		int	nr_subdiv,
		double	plane_radius,
		PointOutT &	radii
	)			`[inline]`

Estimate the Radius-based Surface Descriptor (RSD) for a given point based on its spatial neighborhood of 3D points with normals.

Parameters:

	surface	the dataset containing the XYZ points
	normals	the dataset containing the surface normals at each point in the dataset
	indices	the neighborhood point indices in the dataset
	max_dist	the upper bound for the considered distance interval
	nr_subdiv	the number of subdivisions for the considered distance interval
	plane_radius	document me
	radii	the output point of a type that should have r_min and r_max fields

Note:: : orientation is neglected!; : we neglect points that are outside the specified interval!

Definition at line 46 of file rsd.hpp.

template<typename PointIn1T , typename PointIn2T , typename PointOutT >

void pcl::concatenateFields	(	const pcl::PointCloud< PointIn1T > &	cloud1_in,
		const pcl::PointCloud< PointIn2T > &	cloud2_in,
		pcl::PointCloud< PointOutT > &	cloud_out
	)			`[inline]`

Concatenate two datasets representing different fields.

Parameters:

	cloud1_in	the first input dataset
	cloud2_in	the second input dataset
	cloud_out	the resultant output dataset created by the concatenation of all the fields in the input datasets

Definition at line 216 of file io.hpp.

bool pcl::concatenatePointCloud	(	const sensor_msgs::PointCloud2 &	cloud1,
		const sensor_msgs::PointCloud2 &	cloud2,
		sensor_msgs::PointCloud2 &	cloud_out
	)

Concatenate two sensor_msgs::PointCloud2. Returns true if successful, false if failed (e.g., name/number of fields differs).

Parameters:

	cloud1	the first input point cloud dataset
	cloud2	the second input point cloud dataset
	cloud_out	the resultant output point cloud dataset

Author:: Radu Bogdan Rusu

Definition at line 49 of file io.cpp.

template<typename PointT >

void pcl::copyPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const std::vector< pcl::PointIndices > &	indices,
		pcl::PointCloud< PointT > &	cloud_out
	)			`[inline]`

Extract the indices of a given point cloud as a new point cloud.

Parameters:

	cloud_in	the input point cloud dataset
	indices	the vector of indices representing the points to be copied from cloud_in
	cloud_out	the resultant output point cloud dataset

Definition at line 179 of file io.hpp.

template<typename PointT >

void pcl::copyPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const PointIndices &	indices,
		pcl::PointCloud< PointT > &	cloud_out
	)			`[inline]`

Extract the indices of a given point cloud as a new point cloud.

Parameters:

	cloud_in	the input point cloud dataset
	indices	the PointIndices structure representing the points to be copied from cloud_in
	cloud_out	the resultant output point cloud dataset

Definition at line 154 of file io.hpp.

template<typename PointT >

void pcl::copyPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const std::vector< int > &	indices,
		pcl::PointCloud< PointT > &	cloud_out
	)			`[inline]`

Extract the indices of a given point cloud as a new point cloud.

Parameters:

	cloud_in	the input point cloud dataset
	indices	the vector of indices representing the points to be copied from cloud_in
	cloud_out	the resultant output point cloud dataset

Definition at line 129 of file io.hpp.

void pcl::copyPointCloud	(	const sensor_msgs::PointCloud2 &	cloud_in,
		const std::vector< int > &	indices,
		sensor_msgs::PointCloud2 &	cloud_out
	)

Extract the indices of a given point cloud as a new point cloud.

Parameters:

	cloud_in	the input point cloud dataset
	indices	the vector of indices representing the points to be copied from cloud_in
	cloud_out	the resultant output point cloud dataset

Definition at line 168 of file io.cpp.

template<typename PointInT , typename PointOutT >

void pcl::copyPointCloud	(	const pcl::PointCloud< PointInT > &	cloud_in,
		pcl::PointCloud< PointOutT > &	cloud_out
	)			`[inline]`

Copy all the fields from a given point cloud into a new point cloud.

Parameters:

	cloud_in	the input point cloud dataset
	cloud_out	the resultant output point cloud dataset

Definition at line 110 of file io.hpp.

template<typename PointT >

void pcl::createMapping	(	const std::vector< sensor_msgs::PointField > &	msg_fields,
		MsgFieldMap &	field_map
	)			`[inline]`

Todo:: One could construct a pathological case where the struct has a field where the serialized data has padding

Definition at line 131 of file conversions.h.

float pcl::CS_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the CS norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 116 of file norms.hpp.

double pcl::deg2rad ( double alpha ) [inline]

Convert an angle from degrees to radians.

Parameters:

alpha

the input angle (in degrees)

Definition at line 62 of file angles.hpp.

float pcl::deg2rad ( float alpha ) [inline]

Convert an angle from degrees to radians.

Parameters:

alpha

the input angle (in degrees)

Definition at line 52 of file angles.hpp.

template<typename PointT >

void pcl::demeanPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const std::vector< int > &	indices,
		const Eigen::Vector4f &	centroid,
		Eigen::MatrixXf &	cloud_out
	)			`[inline]`

Subtract a centroid from a point cloud and return the de-meaned representation as an Eigen matrix.

Parameters:

	cloud_in	the input point cloud
	indices	the set of point indices to use from the input point cloud
	centroid	the centroid of the point cloud
	cloud_out	the resultant output XYZ0 dimensions of cloud_in as an Eigen matrix (4 rows, N pts columns)

Definition at line 97 of file transforms.hpp.

template<typename PointT >

void pcl::demeanPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const Eigen::Vector4f &	centroid,
		Eigen::MatrixXf &	cloud_out
	)			`[inline]`

Subtract a centroid from a point cloud and return the de-meaned representation as an Eigen matrix.

Parameters:

	cloud_in	the input point cloud
	centroid	the centroid of the point cloud
	cloud_out	the resultant output XYZ0 dimensions of cloud_in as an Eigen matrix (4 rows, N pts columns)

Definition at line 79 of file transforms.hpp.

template<typename PointT >

void pcl::demeanPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const std::vector< int > &	indices,
		const Eigen::Vector4f &	centroid,
		pcl::PointCloud< PointT > &	cloud_out
	)			`[inline]`

Subtract a centroid from a point cloud and return the de-meaned representation.

Parameters:

	cloud_in	the input point cloud
	indices	the set of point indices to use from the input point cloud
	centroid	the centroid of the point cloud
	cloud_out	the resultant output point cloud

Definition at line 52 of file transforms.hpp.

template<typename PointT >

void pcl::demeanPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const Eigen::Vector4f &	centroid,
		pcl::PointCloud< PointT > &	cloud_out
	)			`[inline]`

Subtract a centroid from a point cloud and return the de-meaned representation.

Parameters:

	cloud_in	the input point cloud
	centroid	the centroid of the point cloud
	cloud_out	the resultant output point cloud

Definition at line 39 of file transforms.hpp.

float pcl::Div_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the div norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 129 of file norms.hpp.

template<typename Matrix , typename Vector >

void pcl::eigen33	(	const Matrix &	mat,
		Matrix &	evecs,
		Vector &	evals
	)			`[inline]`

Definition at line 178 of file eigen.h.

template<typename PointSource , typename PointTarget >

void pcl::estimateRigidTransformationSVD	(	const pcl::PointCloud< PointSource > &	cloud_src,
		const std::vector< int > &	indices_src,
		const pcl::PointCloud< PointTarget > &	cloud_tgt,
		const std::vector< int > &	indices_tgt,
		Eigen::Matrix4f &	transformation_matrix
	)			`[inline]`

Estimate a rigid rotation transformation between a source and a target point cloud using SVD.

Parameters:

	cloud_src	the source point cloud dataset
	indices_src	the vector of indices describing the points of interest in cloud_src
	cloud_tgt	the target point cloud dataset
	indices_tgt	the vector of indices describing the correspondences of the interst points from indices_src
	transformation_matrix	the resultant transformation matrix

Definition at line 91 of file registration.hpp.

template<typename PointSource , typename PointTarget >

void pcl::estimateRigidTransformationSVD	(	const pcl::PointCloud< PointSource > &	cloud_src,
		const std::vector< int > &	indices_src,
		const pcl::PointCloud< PointTarget > &	cloud_tgt,
		Eigen::Matrix4f &	transformation_matrix
	)			`[inline]`

Estimate a rigid rotation transformation between a source and a target point cloud using SVD.

Parameters:

	cloud_src	the source point cloud dataset
	indices_src	the vector of indices describing the points of interest in cloud_src
	cloud_tgt	the target point cloud dataset
	transformation_matrix	the resultant transformation matrix

Definition at line 144 of file registration.hpp.

template<typename PointSource , typename PointTarget >

void pcl::estimateRigidTransformationSVD	(	const pcl::PointCloud< PointSource > &	cloud_src,
		const pcl::PointCloud< PointTarget > &	cloud_tgt,
		Eigen::Matrix4f &	transformation_matrix
	)			`[inline]`

Estimate a rigid rotation transformation between a source and a target point cloud using SVD.

Parameters:

	cloud_src	the source point cloud dataset
	cloud_tgt	the target point cloud dataset
	transformation_matrix	the resultant transformation matrix

Definition at line 41 of file registration.hpp.

template<typename PointType1 , typename PointType2 >

float pcl::euclideanDistance	(	const PointType1 &	p1,
		const PointType2 &	p2
	)			`[inline]`

Calculate the euclidean distance between the two given points.

template<typename PointT , typename Normal >

void pcl::extractEuclideanClusters	(	const PointCloud< PointT > &	cloud,
		const PointCloud< Normal > &	normals,
		const std::vector< int > &	indices,
		const boost::shared_ptr< KdTree< PointT > > &	tree,
		float	tolerance,
		std::vector< PointIndices > &	clusters,
		double	eps_angle,
		unsigned int	min_pts_per_cluster = `1`,
		unsigned int	max_pts_per_cluster = `(std::numeric_limits<int>::max) ()`
	)			`[inline]`

Decompose a region of space into clusters based on the euclidean distance between points, and the normal angular deviation.

Parameters:

	cloud	the point cloud message
	normals	the point cloud message containing normal information
	indices	a list of point indices to use from cloud
	tree	the spatial locator (e.g., kd-tree) used for nearest neighbors searching

Note:: the tree has to be created as a spatial locator on cloud

Parameters:

	tolerance	the spatial cluster tolerance as a measure in the L2 Euclidean space
	clusters	the resultant clusters containing point indices (as PointIndices)
	eps_angle	the maximum allowed difference between normals in degrees for cluster/region growing
	min_pts_per_cluster	minimum number of points that a cluster may contain (default: 1)
	max_pts_per_cluster	maximum number of points that a cluster may contain (default: max int)

Definition at line 184 of file extract_clusters.h.

template<typename PointT , typename Normal >

void pcl::extractEuclideanClusters	(	const PointCloud< PointT > &	cloud,
		const PointCloud< Normal > &	normals,
		float	tolerance,
		const boost::shared_ptr< KdTree< PointT > > &	tree,
		std::vector< PointIndices > &	clusters,
		double	eps_angle,
		unsigned int	min_pts_per_cluster = `1`,
		unsigned int	max_pts_per_cluster = `(std::numeric_limits<int>::max) ()`
	)			`[inline]`

Decompose a region of space into clusters based on the euclidean distance between points, and the normal angular deviation.

Parameters:

	cloud	the point cloud message
	normals	the point cloud message containing normal information
	tree	the spatial locator (e.g., kd-tree) used for nearest neighbors searching

Note:: the tree has to be created as a spatial locator on cloud

Parameters:

	tolerance	the spatial cluster tolerance as a measure in the L2 Euclidean space
	clusters	the resultant clusters containing point indices (as a vector of PointIndices)
	eps_angle	the maximum allowed difference between normals in degrees for cluster/region growing
	min_pts_per_cluster	minimum number of points that a cluster may contain (default: 1)
	max_pts_per_cluster	maximum number of points that a cluster may contain (default: max int)

Definition at line 87 of file extract_clusters.h.

template<typename PointT >

void pcl::extractEuclideanClusters	(	const PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		const boost::shared_ptr< KdTree< PointT > > &	tree,
		float	tolerance,
		std::vector< PointIndices > &	clusters,
		unsigned int	min_pts_per_cluster = `1`,
		unsigned int	max_pts_per_cluster = `(std::numeric_limits<int>::max) ()`
	)			`[inline]`

Decompose a region of space into clusters based on the Euclidean distance between points.

Parameters:

	cloud	the point cloud message
	indices	a list of point indices to use from cloud
	tree	the spatial locator (e.g., kd-tree) used for nearest neighbors searching

Note:: the tree has to be created as a spatial locator on cloud and indices

Parameters:

	tolerance	the spatial cluster tolerance as a measure in L2 Euclidean space
	clusters	the resultant clusters containing point indices (as a vector of PointIndices)
	min_pts_per_cluster	minimum number of points that a cluster may contain (default: 1)
	max_pts_per_cluster	maximum number of points that a cluster may contain (default: max int)

Definition at line 114 of file extract_clusters.hpp.

template<typename PointT >

void pcl::extractEuclideanClusters	(	const PointCloud< PointT > &	cloud,
		const boost::shared_ptr< KdTree< PointT > > &	tree,
		float	tolerance,
		std::vector< PointIndices > &	clusters,
		unsigned int	min_pts_per_cluster = `1`,
		unsigned int	max_pts_per_cluster = `(std::numeric_limits<int>::max) ()`
	)			`[inline]`

Decompose a region of space into clusters based on the Euclidean distance between points.

Parameters:

	cloud	the point cloud message
	tree	the spatial locator (e.g., kd-tree) used for nearest neighbors searching

Note:: the tree has to be created as a spatial locator on cloud

Parameters:

	tolerance	the spatial cluster tolerance as a measure in L2 Euclidean space
	clusters	the resultant clusters containing point indices (as a vector of PointIndices)
	min_pts_per_cluster	minimum number of points that a cluster may contain (default: 1)
	max_pts_per_cluster	maximum number of points that a cluster may contain (default: max int)

Definition at line 45 of file extract_clusters.hpp.

template<typename PointT >

void pcl::flipNormalTowardsViewpoint	(	const PointT &	point,
		float	vp_x,
		float	vp_y,
		float	vp_z,
		float &	nx,
		float &	ny,
		float &	nz
	)			`[inline]`

Flip (in place) the estimated normal of a point towards a given viewpoint.

Parameters:

	point	a given point
	vp_x	the X coordinate of the viewpoint
	vp_y	the X coordinate of the viewpoint
	vp_z	the X coordinate of the viewpoint
	nx	the resultant X component of the plane normal
	ny	the resultant Y component of the plane normal
	nz	the resultant Z component of the plane normal

Definition at line 152 of file normal_3d.h.

template<typename PointT >

void pcl::flipNormalTowardsViewpoint	(	const PointT &	point,
		float	vp_x,
		float	vp_y,
		float	vp_z,
		Eigen::Vector4f &	normal
	)			`[inline]`

Flip (in place) the estimated normal of a point towards a given viewpoint.

Parameters:

	point	a given point
	vp_x	the X coordinate of the viewpoint
	vp_y	the X coordinate of the viewpoint
	vp_z	the X coordinate of the viewpoint
	normal	the plane normal to be flipped

Definition at line 122 of file normal_3d.h.

template<typename Sequence , typename F >

void pcl::for_each_type ( F f ) [inline]

Definition at line 86 of file for_each_type.h.

template<typename PointT >

void pcl::fromROSMsg	(	const sensor_msgs::PointCloud2 &	msg,
		pcl::PointCloud< PointT > &	cloud
	)			`[inline]`

Definition at line 216 of file conversions.h.

template<typename PointT >

void pcl::fromROSMsg	(	const sensor_msgs::PointCloud2 &	msg,
		pcl::PointCloud< PointT > &	cloud,
		const MsgFieldMap &	field_map
	)			`[inline]`

Definition at line 162 of file conversions.h.

void pcl::getAllPcdFilesInDirectory	(	const std::string &	directory,
		std::vector< std::string > &	file_names
	)			`[inline]`

Find all *.pcd files in the directory and return them sorted.

Parameters:

	directory	the directory to be searched
	file_names	the resulting (sorted) list of .pcd files

Definition at line 40 of file file_io.hpp.

float pcl::getAngle2D ( const float point[2] ) [inline]

Compute the angle in the [ 0, 2*PI ) interval of a point (direction) with a reference (0, 0) in 2D.

Parameters:

point

a 2D point

Definition at line 47 of file boundary.h.

double pcl::getAngle3D	(	const Eigen::Vector4f &	v1,
		const Eigen::Vector4f &	v2
	)			`[inline]`

Compute the smallest angle between two vectors in the [ 0, PI ) interval in 3D.

Parameters:

	v1	the first 3D vector (represented as a Eigen::Vector4f)
	v2	the second 3D vector (represented as a Eigen::Vector4f)

Returns:: the angle between v1 and v2

Definition at line 42 of file common.hpp.

template<typename PointT >

double pcl::getCircumcircleRadius	(	const PointT &	pa,
		const PointT &	pb,
		const PointT &	pc
	)			`[inline]`

Compute the radius of a circumscribed circle for a triangle formed of three points pa, pb, and pc.

Parameters:

	pa	the first point
	pb	the second point
	pc	the third point

Returns:: the radius of the circumscribed circle

Definition at line 350 of file common.hpp.

bool pcl::getEigenAsPointCloud	(	Eigen::MatrixXf &	in,
		sensor_msgs::PointCloud2 &	out
	)

Copy the XYZ dimensions from an Eigen MatrixXf into a sensor_msgs::PointCloud2 message.

Parameters:

	in	the Eigen MatrixXf format containing XYZ0 / point
	out	the resultant point cloud message

Note:: the method assumes that the PointCloud2 message already has the fields set up properly !

Definition at line 121 of file io.cpp.

void pcl::getEulerAngles	(	const Eigen::Affine3f &	t,
		float &	roll,
		float &	pitch,
		float &	yaw
	)			`[inline]`

Extract the Euler angles (XYZ-convention) from the given transformation.

Parameters:

	t	the input transformation matrix
	roll	the resulting roll angle
	pitch	the resulting pitch angle
	yaw	the resulting yaw angle

Definition at line 154 of file transform.hpp.

template<typename PointT >

int pcl::getFieldIndex	(	const pcl::PointCloud< PointT > &	cloud,
		const std::string &	field_name,
		std::vector< sensor_msgs::PointField > &	fields
	)			`[inline]`

Get the index of a specified field (i.e., dimension/channel).

Parameters:

	cloud	the the point cloud message
	field_name	the string defining the field name
	fields	a vector to the original PointField vector that the raw PointCloud message contains

Definition at line 74 of file io.hpp.

int pcl::getFieldIndex	(	const sensor_msgs::PointCloud2 &	cloud,
		const std::string &	field_name
	)			`[inline]`

Get the index of a specified field (i.e., dimension/channel).

Parameters:

	cloud	the the point cloud message
	field_name	the string defining the field name

Definition at line 55 of file io.h.

template<typename PointT >

void pcl::getFields	(	const pcl::PointCloud< PointT > &	cloud,
		std::vector< sensor_msgs::PointField > &	fields
	)			`[inline]`

Get the list of available fields (i.e., dimension/channel).

Parameters:

	cloud	the the point cloud message
	fields	a vector to the original PointField vector that the raw PointCloud message contains

Definition at line 87 of file io.hpp.

int pcl::getFieldSize ( int datatype ) [inline]

Obtains the size of a specific field data type in bytes.

Parameters:

datatype

the field data type (see PointField.h)

Definition at line 103 of file io.h.

std::string pcl::getFieldsList ( const sensor_msgs::PointCloud2 & cloud ) [inline]

Get the available point cloud fields as a space separated string.

Parameters:

cloud

a pointer to the PointCloud message

Definition at line 90 of file io.h.

template<typename PointT >

std::string pcl::getFieldsList ( const pcl::PointCloud< PointT > & cloud ) [inline]

Get the list of all fields available in a given cloud.

Parameters:

cloud

the the point cloud message

Definition at line 96 of file io.hpp.

char pcl::getFieldType ( int type ) [inline]

Obtains the type of the PointField from a specific PointField as a char.

Parameters:

type

the PointField field type

Definition at line 170 of file io.h.

int pcl::getFieldType	(	int	size,
		char	type
	)			`[inline]`

Obtains the type of the PointField from a specific size and type.

Parameters:

	size	the size in bytes of the data field
	type	a char describing the type of the field ('F' = float, 'I' = signed, 'U' = unsigned)

Definition at line 133 of file io.h.

std::string pcl::getFileExtension ( const std::string & input ) [inline]

Get the file extension from the given string (the remaining string after the last '.').

Parameters:

input

the input filename

Returns:: input 's file extension

Definition at line 75 of file file_io.hpp.

std::string pcl::getFilenameWithoutExtension ( const std::string & input ) [inline]

Remove the extension from the given string and return only the filename (everything before the last '.').

Parameters:

input

the input filename (with the file extension)

Returns:: the resulting filename, stripped of its extension

Definition at line 69 of file file_io.hpp.

std::string pcl::getFilenameWithoutPath ( const std::string & input ) [inline]

Remove the path from the given string and return only the filename (the remaining string after the last '/').

Parameters:

input

the input filename (with full path)

Returns:: the resulting filename, stripped of the path

Definition at line 63 of file file_io.hpp.

Eigen::Affine3f pcl::getInverse ( const Eigen::Affine3f & transformation ) [inline]

Get the inverse of an Eigen::Affine3f object.

Parameters:

transformation

the input transformation matrix

Returns:: the resulting inverse of transformation

Definition at line 131 of file transform.hpp.

void pcl::getInverse	(	const Eigen::Affine3f &	transformation,
		Eigen::Affine3f &	inverse_transformation
	)			`[inline]`

Get the inverse of an Eigen::Affine3f object.

Parameters:

	transformation	the input transformation matrix
	inverse_transformation	the resultant inverse of transformation

Definition at line 111 of file transform.hpp.

template<typename PointT >

void pcl::getMaxDistance	(	const pcl::PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		const Eigen::Vector4f &	pivot_pt,
		Eigen::Vector4f &	max_pt
	)			`[inline]`

Get the point at maximum distance from a given point and a given pointcloud.

Parameters:

	cloud	the point cloud data message
	pivot_pt	the point from where to compute the distance
	indices	the vector of point indices to use from cloud
	max_pt	the point in cloud that is the farthest point away from pivot_pt

Definition at line 155 of file common.hpp.

template<typename PointT >

void pcl::getMaxDistance	(	const pcl::PointCloud< PointT > &	cloud,
		const Eigen::Vector4f &	pivot_pt,
		Eigen::Vector4f &	max_pt
	)			`[inline]`

Get the point at maximum distance from a given point and a given pointcloud.

Parameters:

	cloud	the point cloud data message
	pivot_pt	the point from where to compute the distance
	max_pt	the point in cloud that is the farthest point away from pivot_pt

Definition at line 112 of file common.hpp.

void pcl::getMeanStd	(	const std::vector< float > &	values,
		double &	mean,
		double &	stddev
	)			`[inline]`

Compute both the mean and the standard deviation of an array of values.

Parameters:

	values	the array of values
	mean	the resultant mean of the distribution
	stddev	the resultant standard deviation of the distribution

Definition at line 53 of file common.hpp.

void pcl::getMeanStdDev	(	const std::vector< float > &	values,
		double &	mean,
		double &	stddev
	)			`[inline]`

Compute both the mean and the standard deviation of an array of values.

Parameters:

	values	the array of values
	mean	the resultant mean of the distribution
	stddev	the resultant standard deviation of the distribution

Definition at line 179 of file common.h.

void pcl::getMinMax	(	const sensor_msgs::PointCloud2 &	cloud,
		int	idx,
		const std::string &	field_name,
		float &	min_p,
		float &	max_p
	)			`[inline]`

Get the minimum and maximum values on a point histogram.

Parameters:

	cloud	the cloud containing multi-dimensional histograms
	idx	the point index representing the histogram that we need to compute min/max for
	field_name	the field name containing the multi-dimensional histogram
	min_p	the resultant minimum
	max_p	the resultant maximum

Definition at line 150 of file common.h.

template<typename PointT >

void pcl::getMinMax	(	const PointT &	histogram,
		int	len,
		float &	min_p,
		float &	max_p
	)			`[inline]`

Get the minimum and maximum values on a point histogram.

Parameters:

	histogram	the point representing a multi-dimensional histogram
	len	the length of the histogram
	min_p	the resultant minimum
	max_p	the resultant maximum

Definition at line 367 of file common.hpp.

template<typename PointT >

void pcl::getMinMax3D	(	const typename pcl::PointCloud< PointT >::ConstPtr &	cloud,
		const std::string &	distance_field_name,
		float	min_distance,
		float	max_distance,
		Eigen::Vector4f &	min_pt,
		Eigen::Vector4f &	max_pt,
		bool	limit_negative = `false`
	)			`[inline]`

Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud, without considering points outside of a distance threshold from the laser origin.

Parameters:

	cloud	the point cloud data message
	distance_field_name	the field name that contains the distance values
	min_distance	the minimum distance a point will be considered from
	max_distance	the maximum distance a point will be considered to
	min_pt	the resultant minimum bounds
	max_pt	the resultant maximum bounds
	limit_negative	if set to true, then all points outside of the interval (min_distance;max_distace) are considered

Definition at line 45 of file voxel_grid.hpp.

void pcl::getMinMax3D	(	const sensor_msgs::PointCloud2ConstPtr &	cloud,
		int	x_idx,
		int	y_idx,
		int	z_idx,
		const std::string &	distance_field_name,
		float	min_distance,
		float	max_distance,
		Eigen::Vector4f &	min_pt,
		Eigen::Vector4f &	max_pt,
		bool	limit_negative = `false`
	)

Definition at line 91 of file voxel_grid.cpp.

void pcl::getMinMax3D	(	const sensor_msgs::PointCloud2ConstPtr &	cloud,
		int	x_idx,
		int	y_idx,
		int	z_idx,
		Eigen::Vector4f &	min_pt,
		Eigen::Vector4f &	max_pt
	)

Definition at line 46 of file voxel_grid.cpp.

template<typename PointT >

void pcl::getMinMax3D	(	const pcl::PointCloud< PointT > &	cloud,
		const pcl::PointIndices &	indices,
		Eigen::Vector4f &	min_pt,
		Eigen::Vector4f &	max_pt
	)			`[inline]`

Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud.

Parameters:

	cloud	the point cloud data message
	indices	the vector of point indices to use from cloud
	min_pt	the resultant minimum bounds
	max_pt	the resultant maximum bounds

Definition at line 277 of file common.hpp.

template<typename PointT >

void pcl::getMinMax3D	(	const pcl::PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		Eigen::Vector4f &	min_pt,
		Eigen::Vector4f &	max_pt
	)			`[inline]`

Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud.

Parameters:

	cloud	the point cloud data message
	indices	the vector of point indices to use from cloud
	min_pt	the resultant minimum bounds
	max_pt	the resultant maximum bounds

Definition at line 315 of file common.hpp.

template<typename PointT >

void pcl::getMinMax3D	(	const pcl::PointCloud< PointT > &	cloud,
		Eigen::Vector4f &	min_pt,
		Eigen::Vector4f &	max_pt
	)			`[inline]`

Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud.

Parameters:

	cloud	the point cloud data message
	min_pt	the resultant minimum bounds
	max_pt	the resultant maximum bounds

Definition at line 239 of file common.hpp.

template<typename PointT >

void pcl::getMinMax3D	(	const pcl::PointCloud< PointT > &	cloud,
		PointT &	min_pt,
		PointT &	max_pt
	)			`[inline]`

Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud.

Parameters:

	cloud	the point cloud data message
	min_pt	the resultant minimum bounds
	max_pt	the resultant maximum bounds

Definition at line 202 of file common.hpp.

bool pcl::getPointCloudAsEigen	(	const sensor_msgs::PointCloud2 &	in,
		Eigen::MatrixXf &	out
	)

Copy the XYZ dimensions of a sensor_msgs::PointCloud2 into Eigen format.

Parameters:

	in	the point cloud message
	out	the resultant Eigen MatrixXf format containing XYZ0 / point

Definition at line 79 of file io.cpp.

template<typename PointT >

void pcl::getPointCloudDifference	(	const pcl::PointCloud< PointT > &	src,
		const pcl::PointCloud< PointT > &	tgt,
		double	threshold,
		const boost::shared_ptr< pcl::KdTree< PointT > > &	tree,
		pcl::PointCloud< PointT > &	output
	)			`[inline]`

Obtain the difference between two aligned point clouds as another point cloud, given a distance threshold.

Parameters:

	src	the input point cloud source
	tgt	the input point cloud target we need to obtain the difference against
	threshold	the distance threshold (tolerance) for point correspondences. (e.g., check if f a point p1 from src has a correspondence > threshold than a point p2 from tgt)
	tree	the spatial locator (e.g., kd-tree) used for nearest neighbors searching built over tgt
	output	the resultant output point cloud difference

Definition at line 46 of file segment_differences.hpp.

template<typename PointT >

void pcl::getPointsInBox	(	const pcl::PointCloud< PointT > &	cloud,
		Eigen::Vector4f &	min_pt,
		Eigen::Vector4f &	max_pt,
		std::vector< int > &	indices
	)			`[inline]`

Get a set of points residing in a box given its bounds.

Parameters:

	cloud	the point cloud data message
	min_pt	the minimum bounds
	max_pt	the maximum bounds
	indices	the resultant set of point indices residing in the box

Definition at line 69 of file common.hpp.

Eigen::Affine3f pcl::getRotation ( const Eigen::Affine3f & transformation ) [inline]

Get only the rotation part of the transformation.

Parameters:

transformation

the input transformation matrix

Returns:: the resulting 3D rotation matrix

Eigen::Affine3f pcl::getRotationOnly ( const Eigen::Affine3f & transformation ) [inline]

Definition at line 99 of file transform.hpp.

double pcl::getTime ( ) [inline]

Definition at line 39 of file time.hpp.

Eigen::Affine3f pcl::getTransformation	(	float	x,
		float	y,
		float	z,
		float	roll,
		float	pitch,
		float	yaw
	)			`[inline]`

Create a transformation from the given translation and Euler angles (XYZ-convention).

Parameters:

	x	the input x translation
	y	the input y translation
	z	the input z translation
	roll	the input roll angle
	pitch	the input pitch angle
	yaw	the input yaw angle

Returns:: the resulting transformation matrix

Definition at line 181 of file transform.hpp.

void pcl::getTransformation	(	float	x,
		float	y,
		float	z,
		float	roll,
		float	pitch,
		float	yaw,
		Eigen::Affine3f &	t
	)			`[inline]`

Create a transformation from the given translation and Euler angles (XYZ-convention).

Parameters:

	x	the input x translation
	y	the input y translation
	z	the input z translation
	roll	the input roll angle
	pitch	the input pitch angle
	yaw	the input yaw angle
	t	the resulting transformation matrix

Definition at line 171 of file transform.hpp.

Eigen::Affine3f pcl::getTransformationFromTwoUnitVectors	(	const Eigen::Vector3f &	y_direction,
		const Eigen::Vector3f &	z_axis
	)			`[inline]`

Same as getTransFromUnitVectorsZY - for downwards compatibility

Definition at line 84 of file transform.hpp.

void pcl::getTransformationFromTwoUnitVectors	(	const Eigen::Vector3f &	y_direction,
		const Eigen::Vector3f &	z_axis,
		Eigen::Affine3f &	transformation
	)			`[inline]`

Same as getTransFromUnitVectorsZY - for downwards compatibility

Definition at line 79 of file transform.hpp.

void pcl::getTransformationFromTwoUnitVectorsAndOrigin	(	const Eigen::Vector3f &	y_direction,
		const Eigen::Vector3f &	z_axis,
		const Eigen::Vector3f &	origin,
		Eigen::Affine3f &	transformation
	)			`[inline]`

Get the transformation that will translate orign to (0,0,0) and rotate z_axis into (0,0,1) and y_direction into a vector with x=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).

Parameters:

	y_direction	the y direction
	z_axis	the z-axis
	origin	the origin
	transformation	the resultant transformation matrix

Definition at line 91 of file transform.hpp.

template<typename PointCloudType >

void pcl::getTransformedPointCloud	(	const PointCloudType &	input,
		const Eigen::Affine3f &	transformation,
		PointCloudType &	output
	)			`[inline]`

Transform each point in the given point cloud according to the given transformation.

Parameters:

	input	the input point cloud
	transformation	the transformation matrix to apply
	output	the resulting transformed point cloud

Definition at line 147 of file transform.hpp.

Eigen::Affine3f pcl::getTransFromUnitVectorsXY	(	const Eigen::Vector3f &	x_axis,
		const Eigen::Vector3f &	y_direction
	)			`[inline]`

Get the unique 3D rotation that will rotate x_axis into (1,0,0) and y_direction into a vector with z=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).

Parameters:

	x_axis	the x-axis
	y_direction	the y direction

Returns:: the resulting 3D rotation

Definition at line 72 of file transform.hpp.

void pcl::getTransFromUnitVectorsXY	(	const Eigen::Vector3f &	x_axis,
		const Eigen::Vector3f &	y_direction,
		Eigen::Affine3f &	transformation
	)			`[inline]`

Get the unique 3D rotation that will rotate x_axis into (1,0,0) and y_direction into a vector with z=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).

Parameters:

	x_axis	the x-axis
	y_direction	the y direction
	transformation	the resultant 3D rotation

Definition at line 60 of file transform.hpp.

Eigen::Affine3f pcl::getTransFromUnitVectorsZY	(	const Eigen::Vector3f &	z_axis,
		const Eigen::Vector3f &	y_direction
	)			`[inline]`

Get the unique 3D rotation that will rotate z_axis into (0,0,1) and y_direction into a vector with x=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).

Parameters:

	z_axis	the z-axis
	y_direction	the y direction

Returns:: the resultant 3D rotation

Definition at line 53 of file transform.hpp.

void pcl::getTransFromUnitVectorsZY	(	const Eigen::Vector3f &	z_axis,
		const Eigen::Vector3f &	y_direction,
		Eigen::Affine3f &	transformation
	)			`[inline]`

Get the unique 3D rotation that will rotate z_axis into (0,0,1) and y_direction into a vector with x=0 (or into (0,1,0) should y_direction be orthogonal to z_axis).

Parameters:

	z_axis	the z-axis
	y_direction	the y direction
	transformation	the resultant 3D rotation

Definition at line 41 of file transform.hpp.

Eigen::Vector3f pcl::getTranslation ( const Eigen::Affine3f & transformation ) [inline]

Get only the translation part of the transformation.

Parameters:

transformation

the input transformation matrix

Returns:: the resulting translation matrix

Definition at line 106 of file transform.hpp.

void pcl::getTranslationAndEulerAngles	(	const Eigen::Affine3f &	t,
		float &	x,
		float &	y,
		float &	z,
		float &	roll,
		float &	pitch,
		float &	yaw
	)			`[inline]`

Extract x,y,z and the Euler angles (XYZ-convention) from the given transformation

Parameters:

	t	the input transformation matrix
	x	the resulting x translation
	y	the resulting y translation
	z	the resulting z translation
	roll	the resulting roll angle
	pitch	the resulting pitch angle
	yaw	the resulting yaw angle

Definition at line 161 of file transform.hpp.

template<typename PointType >

bool pcl::hasValidXYZ ( const PointType & p ) [inline]

Checks if x,y,z are finite numbers.

float pcl::HIK_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the HIK norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 174 of file norms.hpp.

template<typename PointT >

void pcl::initTree	(	const int &	spatial_locator,
		boost::shared_ptr< pcl::KdTree< PointT > > &	tree,
		int	k = `0`
	)			`[inline]`

Initialize the spatial locator used for nearest neighbor search.

Parameters:

	spatial_locator	the type of spatial locator to construct (0 = FLANN, 1 = organized)
	tree	the resultant tree as a boost shared pointer
	k	optional parameter (default 0) applied only if the spatial locator is set to organized (1)

Definition at line 47 of file tree_types.hpp.

bool pcl::isBetterCorrespondence	(	const PointCorrespondence &	pc1,
		const PointCorrespondence &	pc2
	)			`[inline]`

Comparator to enable us to sort a vector of PointCorrespondences according to their scores using std::sort(begin(), end(), isBetterCorrespondence);.

Definition at line 93 of file point_correspondence.h.

template<typename PointT >

bool pcl::isPointIn2DPolygon	(	const PointT &	point,
		const pcl::PointCloud< PointT > &	polygon
	)			`[inline]`

General purpose method for checking if a 3D point is inside or outside a given 2D polygon.

Note:: this method accepts any general 3D point that is projected onto the 2D polygon, but performs an internal XY projection of both the polygon and the point.

Parameters:

	point	a 3D point projected onto the same plane as the polygon
	polygon	a polygon

Definition at line 45 of file extract_polygonal_prism_data.hpp.

template<typename PointT >

bool pcl::isXYPointIn2DXYPolygon	(	const PointT &	point,
		const pcl::PointCloud< PointT > &	polygon
	)			`[inline]`

Check if a 2d point (X and Y coordinates considered only!) is inside or outside a given polygon. This method assumes that both the point and the polygon are projected onto the XY plane.

Note:: (This is highly optimized code taken from http://www.visibone.com/inpoly/) Copyright (c) 1995-1996 Galacticomm, Inc. Freeware source code.

Parameters:

	point	a 3D point projected onto the same plane as the polygon
	polygon	a polygon

Definition at line 90 of file extract_polygonal_prism_data.hpp.

float pcl::JM_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the JM norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 78 of file norms.hpp.

float pcl::K_Norm	(	float *	A,
		float *	B,
		int	dim,
		float	P1,
		float	P2
	)			`[inline]`

Compute the K norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)
	P1	the first parameter
	P2	the second parameter

Definition at line 152 of file norms.hpp.

float pcl::KL_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the KL between two discrete probability density functions.

Parameters:

	A	the first discrete PDF
	B	the second discrete PDF
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 162 of file norms.hpp.

float pcl::L1_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the L1 norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 42 of file norms.hpp.

float pcl::L2_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the L2 norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 63 of file norms.hpp.

float pcl::L2_Norm_SQR	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the squared L2 norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 51 of file norms.hpp.

void pcl::lineToLineSegment	(	const Eigen::VectorXf &	line_a,
		const Eigen::VectorXf &	line_b,
		Eigen::Vector4f &	pt1_seg,
		Eigen::Vector4f &	pt2_seg
	)

Get the shortest 3D segment between two 3D lines.

Parameters:

	line_a	the coefficients of the first line (point, direction)
	line_b	the coefficients of the second line (point, direction)
	pt1_seg	the first point on the line segment
	pt2_seg	the second point on the line segment

Definition at line 40 of file distances.cpp.

bool pcl::lineWithLineIntersection	(	const pcl::ModelCoefficients &	line_a,
		const pcl::ModelCoefficients &	line_b,
		Eigen::Vector4f &	point,
		double	sqr_eps = `1e-4`
	)			`[inline]`

Get the intersection of a two 3D lines in space as a 3D point.

Parameters:

	line_a	the coefficients of the first line (point, direction)
	line_b	the coefficients of the second line (point, direction)
	point	holder for the computed 3D point
	sqr_eps	maximum allowable squared distance to the true solution

Definition at line 59 of file intersections.cpp.

bool pcl::lineWithLineIntersection	(	const Eigen::VectorXf &	line_a,
		const Eigen::VectorXf &	line_b,
		Eigen::Vector4f &	point,
		double	sqr_eps = `1e-4`
	)

Get the intersection of a two 3D lines in space as a 3D point.

Parameters:

	line_a	the coefficients of the first line (point, direction)
	line_b	the coefficients of the second line (point, direction)
	point	holder for the computed 3D point
	sqr_eps	maximum allowable squared distance to the true solution

Definition at line 41 of file intersections.cpp.

float pcl::Linf_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the L-infinity norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 69 of file norms.hpp.

template<typename Derived >

void pcl::loadBinary	(	Eigen::MatrixBase< Derived > &	matrix,
		std::istream &	file
	)			`[inline]`

Read a matrix from an input stream.

Parameters:

	matrix	the resulting matrix, read from the input stream
	file	the input stream

Definition at line 203 of file transform.hpp.

template<typename real >

real pcl::normAngle ( real alpha ) [inline]

Normalize an angle to (-PI, PI].

Parameters:

alpha

the input angle (in radians)

Definition at line 42 of file angles.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const RangeImageBorderExtractor::Parameters &	p
	)			`[inline]`

Definition at line 59 of file range_image_border_extractor.hpp.

template<typename ContainerAllocator >

std::ostream& pcl::operator<<	(	std::ostream &	s,
		const ::pcl::Vertices_< ContainerAllocator > &	v
	)			`[inline]`

Definition at line 94 of file gen/cpp/include/pcl/Vertices.h.

template<typename ContainerAllocator >

std::ostream& pcl::operator<<	(	std::ostream &	s,
		const ::pcl::PolygonMesh_< ContainerAllocator > &	v
	)			`[inline]`

Definition at line 188 of file gen/cpp/include/pcl/PolygonMesh.h.

template<typename ContainerAllocator >

std::ostream& pcl::operator<<	(	std::ostream &	s,
		const ::pcl::PointIndices_< ContainerAllocator > &	v
	)			`[inline]`

Definition at line 122 of file gen/cpp/include/pcl/PointIndices.h.

template<typename ContainerAllocator >

std::ostream& pcl::operator<<	(	std::ostream &	s,
		const ::pcl::ModelCoefficients_< ContainerAllocator > &	v
	)			`[inline]`

Definition at line 122 of file gen/cpp/include/pcl/ModelCoefficients.h.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const RangeImage &	r
	)			`[inline]`

Definition at line 635 of file range_image.h.

template<typename PointT >

std::ostream& pcl::operator<<	(	std::ostream &	s,
		const pcl::PointCloud< PointT > &	p
	)			`[inline]`

Definition at line 202 of file point_cloud.h.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const NarfKeypoint::Parameters &	p
	)			`[inline]`

Definition at line 175 of file narf_keypoint.h.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointSurfel &	p
	)			`[inline]`

Definition at line 559 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointWithScale &	p
	)			`[inline]`

Definition at line 536 of file point_types.hpp.

template<int N>

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const Histogram< N > &	p
	)			`[inline]`

Definition at line 523 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const IntensityGradient &	p
	)			`[inline]`

Definition at line 511 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const BorderDescription &	p
	)			`[inline]`

Definition at line 492 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const Narf36 &	p
	)			`[inline]`

Definition at line 477 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const VFHSignature308 &	p
	)			`[inline]`

Definition at line 465 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const FPFHSignature33 &	p
	)			`[inline]`

Definition at line 454 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PFHSignature125 &	p
	)			`[inline]`

Definition at line 443 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PrincipalCurvatures &	p
	)			`[inline]`

Definition at line 433 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const Boundary &	p
	)			`[inline]`

Definition at line 412 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PrincipalRadiiRSD &	p
	)			`[inline]`

Definition at line 402 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const MomentInvariants &	p
	)			`[inline]`

Definition at line 392 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointWithViewpoint &	p
	)			`[inline]`

Definition at line 382 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointWithRange &	p
	)			`[inline]`

Definition at line 352 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointXYZINormal &	p
	)			`[inline]`

Definition at line 333 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointXYZRGBNormal &	p
	)			`[inline]`

Definition at line 312 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointNormal &	p
	)			`[inline]`

Definition at line 290 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const Normal &	p
	)			`[inline]`

Definition at line 269 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const InterestPoint &	p
	)			`[inline]`

Definition at line 249 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointXY &	p
	)			`[inline]`

Definition at line 229 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointXYZRGB &	p
	)			`[inline]`

Definition at line 217 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointXYZRGBA &	p
	)			`[inline]`

Definition at line 196 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointXYZI &	p
	)			`[inline]`

Definition at line 176 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const PointXYZ &	p
	)			`[inline]`

Definition at line 157 of file point_types.hpp.

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const Eigen::Affine3f &	m
	)			`[inline]`

Output operator for Tranform3f.

Parameters:

	os	the output stream
	m	the affine transformation to output

Definition at line 110 of file transform.h.

template<typename real >

std::ostream& pcl::operator<<	(	std::ostream &	os,
		const BivariatePolynomialT< real > &	p
	)			`[inline]`

Definition at line 192 of file bivariate_polynomial.hpp.

float pcl::PF_Norm	(	float *	A,
		float *	B,
		int	dim,
		float	P1,
		float	P2
	)			`[inline]`

Compute the PF norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)
	P1	the first parameter
	P2	the second parameter

Definition at line 142 of file norms.hpp.

template<typename Point >

double pcl::pointToPlaneDistance	(	const Point &	p,
		const Eigen::Vector4f &	plane_coefficients
	)			`[inline]`

Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0.

Parameters:

	p	a point
	plane_coefficients	the normalized coefficients (a, b, c, d) of a plane

Definition at line 89 of file sac_model_plane.h.

template<typename Point >

double pcl::pointToPlaneDistance	(	const Point &	p,
		double	a,
		double	b,
		double	c,
		double	d
	)			`[inline]`

Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0.

Parameters:

	p	a point
	a	the normalized a coefficient of a plane
	b	the normalized b coefficient of a plane
	c	the normalized c coefficient of a plane
	d	the normalized d coefficient of a plane

Definition at line 79 of file sac_model_plane.h.

template<typename Point >

double pcl::pointToPlaneDistanceSigned	(	const Point &	p,
		const Eigen::Vector4f &	plane_coefficients
	)			`[inline]`

Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0.

Parameters:

	p	a point
	plane_coefficients	the normalized coefficients (a, b, c, d) of a plane

Definition at line 66 of file sac_model_plane.h.

template<typename Point >

double pcl::pointToPlaneDistanceSigned	(	const Point &	p,
		double	a,
		double	b,
		double	c,
		double	d
	)			`[inline]`

Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0.

Parameters:

	p	a point
	a	the normalized a coefficient of a plane
	b	the normalized b coefficient of a plane
	c	the normalized c coefficient of a plane
	d	the normalized d coefficient of a plane

Definition at line 56 of file sac_model_plane.h.

double pcl::rad2deg ( double alpha ) [inline]

Convert an angle from radians to degrees.

Parameters:

alpha

the input angle (in radians)

Definition at line 57 of file angles.hpp.

float pcl::rad2deg ( float alpha ) [inline]

Convert an angle from radians to degrees.

Parameters:

alpha

the input angle (in radians)

Definition at line 47 of file angles.hpp.

template<typename PointT >

void pcl::removeNaNFromPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		pcl::PointCloud< PointT > &	cloud_out,
		std::vector< int > &	index
	)			`[inline]`

Removes points with x, y, or z equal to NaN.

Parameters:

	cloud_in	the input point cloud
	cloud_out	the input point cloud
	index	the mapping (ordered): cloud_out.points[i] = cloud_in.points[index[i]]

Note:: The density of the point cloud is lost.; Can be called with cloud_in == cloud_out

Definition at line 45 of file filter.hpp.

static const std::map<pcl::SacModel, unsigned int> pcl::SAC_SAMPLE_SIZE	(	sample_size_pairs	,
		sample_size_pairs+	sizeofsample_size_pairs)/sizeof(SampleSizeModel
	)			`[static]`

template<typename Derived >

void pcl::saveBinary	(	const Eigen::MatrixBase< Derived > &	matrix,
		std::ostream &	file
	)			`[inline]`

Write a matrix to an output stream.

Parameters:

	matrix	the matrix to output
	file	the output stream

Definition at line 189 of file transform.hpp.

void pcl::solvePlaneParameters	(	const Eigen::Matrix3f &	covariance_matrix,
		float &	nx,
		float &	ny,
		float &	nz,
		float &	curvature
	)			`[inline]`

Solve the eigenvalues and eigenvectors of a given 3x3 covariance matrix, and estimate the least-squares plane normal and surface curvature.

Parameters:

	covariance_matrix	the 3x3 covariance matrix
	nx	the resultant X component of the plane normal
	ny	the resultant Y component of the plane normal
	nz	the resultant Z component of the plane normal
	curvature	the estimated surface curvature as a measure of $\lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)$

Definition at line 388 of file feature.hpp.

void pcl::solvePlaneParameters	(	const Eigen::Matrix3f &	covariance_matrix,
		const Eigen::Vector4f &	point,
		Eigen::Vector4f &	plane_parameters,
		float &	curvature
	)			`[inline]`

Solve the eigenvalues and eigenvectors of a given 3x3 covariance matrix, and estimate the least-squares plane normal and surface curvature.

Parameters:

	covariance_matrix	the 3x3 covariance matrix
	point	a point lying on the least-squares plane (SSE aligned)
	plane_parameters	the resultant plane parameters as: a, b, c, d (ax + by + cz + d = 0)
	curvature	the estimated surface curvature as a measure of $\lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)$

Definition at line 338 of file feature.hpp.

double pcl::sqrPointToLineDistance	(	const Eigen::Vector4f &	pt,
		const Eigen::Vector4f &	line_pt,
		const Eigen::Vector4f &	line_dir,
		const double	sqr_length
	)			`[inline]`

Get the square distance from a point to a line (represented by a point and a direction).

Note:: This one is useful if one has to compute many distances to a fixed line, so the vector length can be pre-computed

Parameters:

	pt	a point
	line_pt	a point on the line (make sure that line_pt[3] = 0 as there are no internal checks!)
	line_dir	the line direction
	sqr_length	the squared norm of the line direction

Definition at line 75 of file distances.h.

double pcl::sqrPointToLineDistance	(	const Eigen::Vector4f &	pt,
		const Eigen::Vector4f &	line_pt,
		const Eigen::Vector4f &	line_dir
	)			`[inline]`

Get the square distance from a point to a line (represented by a point and a direction).

Parameters:

	pt	a point
	line_pt	a point on the line (make sure that line_pt[3] = 0 as there are no internal checks!)
	line_dir	the line direction

Definition at line 60 of file distances.h.

template<typename PointType1 , typename PointType2 >

float pcl::squaredEuclideanDistance	(	const PointType1 &	p1,
		const PointType2 &	p2
	)			`[inline]`

Calculate the squared euclidean distance between the two given points.

float pcl::Sublinear_Norm	(	float *	A,
		float *	B,
		int	dim
	)			`[inline]`

Compute the sublinear norm of the vector between two points.

Parameters:

	A	the first point
	B	the second point
	dim	the number of dimensions in A and B (dimensions must match)

Definition at line 105 of file norms.hpp.

void pcl::toROSMsg	(	const sensor_msgs::PointCloud2 &	cloud,
		sensor_msgs::Image &	msg
	)			`[inline]`

Copy the RGB fields of a PointCloud2 msg into sensor_msgs::Image format.

Parameters:

	cloud	the point cloud message
	msg	the resultant sensor_msgs::Image will throw std::runtime_error if there is a problem

Definition at line 294 of file conversions.h.

template<typename CloudT >

void pcl::toROSMsg	(	const CloudT &	cloud,
		sensor_msgs::Image &	msg
	)			`[inline]`

Copy the RGB fields of a PointCloud into sensor_msgs::Image format.

Parameters:

	cloud	the point cloud message
	msg	the resultant sensor_msgs::Image CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGB> will throw std::runtime_error if there is a problem

Definition at line 262 of file conversions.h.

template<typename PointT >

void pcl::toROSMsg	(	const pcl::PointCloud< PointT > &	cloud,
		sensor_msgs::PointCloud2 &	msg
	)			`[inline]`

Todo:: msg.is_bigendian = ?;

Definition at line 224 of file conversions.h.

template<typename PointT >

void pcl::transformPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		pcl::PointCloud< PointT > &	cloud_out,
		const Eigen::Vector3f &	offset,
		const Eigen::Quaternionf &	rotation
	)			`[inline]`

Apply a rigid transform defined by a 3D offset and a quaternion.

Parameters:

	cloud_in	the input point cloud
	cloud_out	the resultant output point cloud
	offset	the translation component of the rigid transformation
	rotation	the rotation component of the rigid transformation

Note:: density of the point cloud is lost, since density implies that the origin is the point of view

Definition at line 337 of file transforms.hpp.

template<typename PointT >

void pcl::transformPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		pcl::PointCloud< PointT > &	cloud_out,
		const Eigen::Matrix4f &	transform
	)			`[inline]`

Apply an affine transform defined by an Eigen Transform.

Parameters:

	cloud_in	the input point cloud
	cloud_out	the resultant output point cloud
	transform	an affine transformation (typically a rigid transformation)

Note:: The density of the point cloud is lost, since density implies that the origin is the point of view; Can be used with cloud_in equal to cloud_out

Definition at line 244 of file transforms.hpp.

template<typename PointT >

void pcl::transformPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const std::vector< int > &	indices,
		pcl::PointCloud< PointT > &	cloud_out,
		const Eigen::Affine3f &	transform
	)			`[inline]`

Apply an affine transform defined by an Eigen Transform.

Parameters:

	cloud_in	the input point cloud
	indices	the set of point indices to use from the input point cloud
	cloud_out	the resultant output point cloud
	transform	an affine transformation (typically a rigid transformation)

Note:: The density of the point cloud is lost, since density implies that the origin is the point of view; Can be used with cloud_in equal to cloud_out

Definition at line 157 of file transforms.hpp.

template<typename PointT >

void pcl::transformPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		pcl::PointCloud< PointT > &	cloud_out,
		const Eigen::Affine3f &	transform
	)			`[inline]`

Apply an affine transform defined by an Eigen Transform.

Parameters:

	cloud_in	the input point cloud
	cloud_out	the resultant output point cloud
	transform	an affine transformation (typically a rigid transformation)

Note:: The density of the point cloud is lost, since density implies that the origin is the point of view; Can be used with cloud_in equal to cloud_out

Definition at line 116 of file transforms.hpp.

template<typename PointT >

void pcl::transformPointCloudWithNormals	(	const pcl::PointCloud< PointT > &	cloud_in,
		pcl::PointCloud< PointT > &	cloud_out,
		const Eigen::Vector3f &	offset,
		const Eigen::Quaternionf &	rotation
	)			`[inline]`

Transform a point cloud and rotate its normals using an Eigen transform.

Parameters:

	cloud_in	the input point cloud
	cloud_out	the resultant output point cloud
	offset	the translation component of the rigid transformation
	rotation	the rotation component of the rigid transformation

Note:: density of the point cloud is lost, since density implies that the origin is the point of view

Definition at line 351 of file transforms.hpp.

template<typename PointT >

void pcl::transformPointCloudWithNormals	(	const pcl::PointCloud< PointT > &	cloud_in,
		pcl::PointCloud< PointT > &	cloud_out,
		const Eigen::Matrix4f &	transform
	)			`[inline]`

Transform a point cloud and rotate its normals using an Eigen transform.

Parameters:

	cloud_in	the input point cloud
	cloud_out	the resultant output point cloud
	transform	an affine transformation (typically a rigid transformation)

Note:: The density of the point cloud is lost, since density implies that the origin is the point of view; Can be used with cloud_in equal to cloud_out

Definition at line 285 of file transforms.hpp.

template<typename PointT >

void pcl::transformPointCloudWithNormals	(	const pcl::PointCloud< PointT > &	cloud_in,
		pcl::PointCloud< PointT > &	cloud_out,
		const Eigen::Affine3f &	transform
	)			`[inline]`

Transform a point cloud and rotate its normals using an Eigen transform.

Parameters:

	cloud_in	the input point cloud
	cloud_out	the resultant output point cloud
	transform	an affine transformation (typically a rigid transformation)

Note:: The density of the point cloud is lost, since density implies that the origin is the point of view; Can be used with cloud_in equal to cloud_out

Definition at line 195 of file transforms.hpp.

template<typename PointType >

PointType pcl::transformXYZ	(	const Eigen::Affine3f &	transformation,
		const PointType &	point
	)			`[inline]`

Transform a point with members x,y,z.

Parameters:

	transformation	the transformation to apply
	point	the point to transform

Returns:: the transformed point

Definition at line 139 of file transform.hpp.

Variable Documentation

struct pcl::PointSurfel pcl::EIGEN_ALIGN16

const int pcl::I_SHIFT_EDGE[3][2]

Initial value:

 {
    {0,1}, {1,3}, {1,2}
  }

Definition at line 58 of file grid_projection.h.

const int pcl::I_SHIFT_EP[12][2]

Initial value:

 {
    {0, 4}, {1, 5}, {2, 6}, {3, 7}, 
    {0, 1}, {1, 2}, {2, 3}, {3, 0},
    {4, 5}, {5, 6}, {6, 7}, {7, 4}
  }

The 12 edges of a cell.

Definition at line 48 of file grid_projection.h.

const int pcl::I_SHIFT_PT[4]

Initial value:

 {
    0, 4, 5, 7
  }

Definition at line 54 of file grid_projection.h.

const int pcl::KDTREE_FLANN = 0 [static]

Definition at line 45 of file tree_types.h.

const int pcl::KDTREE_ORGANIZED_INDEX = 1 [static]

Definition at line 46 of file tree_types.h.

const int pcl::SAC_LMEDS = 1 [static]

Definition at line 44 of file method_types.h.

const int pcl::SAC_MLESAC = 5 [static]

Definition at line 48 of file method_types.h.

const int pcl::SAC_MSAC = 2 [static]

Definition at line 45 of file method_types.h.

const int pcl::SAC_RANSAC = 0 [static]

Definition at line 43 of file method_types.h.

const int pcl::SAC_RMSAC = 4 [static]

Definition at line 47 of file method_types.h.

const int pcl::SAC_RRANSAC = 3 [static]

Definition at line 46 of file method_types.h.

pcl Namespace Reference

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation