Detailed Description

Overview

The pcl_common library contains the common data structures and methods used by the majority of PCL libraries. The core data structures include the PointCloud class and a multitude of point types that are used to represent points, surface normals, RGB color values, feature descriptors, etc. It also contains numerous functions for computing distances/norms, means and covariances, angular conversions, geometric transformations, and more.

Requirements

none

Classes
class	pcl::BivariatePolynomialT< real >
	This represents a bivariate polynomial and provides some functionality for it. More...
struct	pcl::NdConcatenateFunctor< PointInT, PointOutT >
	Helper functor structure for concatenate. More...
class	pcl::common::Convolution< PointOperatorsType >
	Class Convolution Convolution is a mathematical operation on two functions f and g, producing a third function that is typically viewed as a modified version of one of the original functions. More...
class	pcl::GaussianKernel
	Class GaussianKernel assembles all the method for computing, convolving, smoothing, gradients computing an image using a gaussian kernel. More...
class	pcl::PCA< PointT >
	Principal Component analysis (PCA) class. More...
class	pcl::PiecewiseLinearFunction
	This provides functionalities to efficiently return values for piecewise linear function. More...
struct	pcl::common::PointOperators< PointIN, PointOUT >
	PointOperators is a struct that provides basic arithmetic operations on points: addition, product and plus-assign operation. More...
class	pcl::PolynomialCalculationsT< real >
	This provides some functionality for polynomials, like finding roots or approximating bivariate polynomials. More...
class	pcl::PosesFromMatches
	calculate 3D transformation based on point correspondencdes More...
class	pcl::StopWatch
	Simple stopwatch. More...
class	pcl::ScopeTime
	Class to measure the time spent in a scope. More...
class	pcl::TimeTrigger
	timer class that invokes registered callback methods periodically. More...
class	pcl::TransformationFromCorrespondences
	Calculates a transformation based on corresponding 3D points. More...
class	pcl::VectorAverage< real, dimension >
	Calculates the weighted average and the covariance matrix. More...
struct	pcl::Correspondence
	Correspondence represents a match between two entities (e.g., points, descriptors, etc). More...
struct	pcl::PointCorrespondence3D
	Representation of a (possible) correspondence between two 3D points in two different coordinate frames (e.g. More...
struct	pcl::PointCorrespondence6D
	Representation of a (possible) correspondence between two points (e.g. More...
struct	pcl::PointXYZ
	A point structure representing Euclidean xyz coordinates. More...
struct	pcl::PointXYZI
	A point structure representing Euclidean xyz coordinates, and the intensity value. More...
struct	pcl::_PointXYZRGBA
	A point structure representing Euclidean xyz coordinates, and the RGBA color. More...
struct	pcl::PointXYZRGB
	A point structure representing Euclidean xyz coordinates, and the RGB color. More...
struct	pcl::PointXY
	A 2D point structure representing Euclidean xy coordinates. More...
struct	pcl::InterestPoint
	A point structure representing an interest point with Euclidean xyz coordinates, and an interest value. More...
struct	pcl::Normal
	A point structure representing normal coordinates and the surface curvature estimate. More...
struct	pcl::PointNormal
	A point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate. More...
struct	pcl::_PointXYZRGBNormal
	A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate. More...
struct	pcl::PointXYZINormal
	A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate. More...
struct	pcl::PointWithRange
	A point structure representing Euclidean xyz coordinates, padded with an extra range float. More...
struct	pcl::PointWithViewpoint
	A point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen. More...
struct	pcl::MomentInvariants
	A point structure representing the three moment invariants. More...
struct	pcl::PrincipalRadiiRSD
	A point structure representing the minimum and maximum surface radii (in meters) computed using RSD. More...
struct	pcl::Boundary
	A point structure representing a description of whether a point is lying on a surface boundary or not. More...
struct	pcl::PrincipalCurvatures
	A point structure representing the principal curvatures and their magnitudes. More...
struct	pcl::PFHSignature125
	A point structure representing the Point Feature Histogram (PFH). More...
struct	pcl::PFHRGBSignature250
	A point structure representing the Point Feature Histogram with colors (PFHRGB). More...
struct	pcl::PPFSignature
	A point structure for storing the Point Pair Feature (PPF) values. More...
struct	pcl::PPFRGBSignature
	A point structure for storing the Point Pair Color Feature (PPFRGB) values. More...
struct	pcl::NormalBasedSignature12
	A point structure representing the Normal Based Signature for a feature matrix of 4-by-3. More...
struct	pcl::SHOT
	A point structure representing the generic Signature of Histograms of OrienTations (SHOT). More...
struct	pcl::FPFHSignature33
	A point structure representing the Signature of Histograms of OrienTations (SHOT). More...
struct	pcl::VFHSignature308
	A point structure representing the Viewpoint Feature Histogram (VFH). More...
struct	pcl::GFPFHSignature16
	A point structure representing the GFPFH descriptor with 16 bins. More...
struct	pcl::Narf36
	A point structure representing the Narf descriptor. More...
struct	pcl::BorderDescription
	A structure to store if a point in a range image lies on a border between an obstacle and the background. More...
struct	pcl::IntensityGradient
	A point structure representing the intensity gradient of an XYZI point cloud. More...
struct	pcl::Histogram< N >
	A point structure representing an N-D histogram. More...
struct	pcl::PointWithScale
	A point structure representing a 3-D position and scale. More...
struct	pcl::PointSurfel
	A surfel, that is, a point structure representing Euclidean xyz coordinates, together with normal coordinates, a RGBA color, a radius, a confidence value and the surface curvature estimate. More...
class	pcl::PCLBase< PointT >
	PCL base class. More...
Files
file	angles.h
	Define standard C methods to do angle calculations.
file	centroid.h
	Define methods for centroid estimation and covariance matrix calculus.
file	common.h
	Define standard C methods and C++ classes that are common to all methods.
file	distances.h
	Define standard C methods to do distance calculations.
file	file_io.h
	Define some helper functions for reading and writing files.
file	geometry.h
	Defines some geometrical functions and utility functions.
file	intersections.h
	Define line with line intersection functions.
file	norms.h
	Define standard C methods to calculate different norms.
file	time.h
	Define methods for measuring time spent in code blocks.
file	point_types.h
	Defines all the PCL implemented PointT point type structures.
Typedefs
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.
Enumerations
enum	pcl::NormType { pcl::L1, pcl::L2_SQR, pcl::L2, pcl::LINF, pcl::JM, pcl::B, pcl::SUBLINEAR, pcl::CS, pcl::DIV, pcl::PF, pcl::K, pcl::KL, pcl::HIK }
	Enum that defines all the types of norms available. More...
enum	pcl::BorderTrait { pcl::BORDER_TRAIT__OBSTACLE_BORDER, pcl::BORDER_TRAIT__SHADOW_BORDER, pcl::BORDER_TRAIT__VEIL_POINT, pcl::BORDER_TRAIT__SHADOW_BORDER_TOP, pcl::BORDER_TRAIT__SHADOW_BORDER_RIGHT, pcl::BORDER_TRAIT__SHADOW_BORDER_BOTTOM, pcl::BORDER_TRAIT__SHADOW_BORDER_LEFT, pcl::BORDER_TRAIT__OBSTACLE_BORDER_TOP, pcl::BORDER_TRAIT__OBSTACLE_BORDER_RIGHT, pcl::BORDER_TRAIT__OBSTACLE_BORDER_BOTTOM, pcl::BORDER_TRAIT__OBSTACLE_BORDER_LEFT, pcl::BORDER_TRAIT__VEIL_POINT_TOP, pcl::BORDER_TRAIT__VEIL_POINT_RIGHT, pcl::BORDER_TRAIT__VEIL_POINT_BOTTOM, pcl::BORDER_TRAIT__VEIL_POINT_LEFT }
	Specification of the fields for BorderDescription::traits. More...
Functions
float	pcl::rad2deg (float alpha)
	Convert an angle from radians to degrees.
float	pcl::deg2rad (float alpha)
	Convert an angle from degrees to radians.
double	pcl::rad2deg (double alpha)
	Convert an angle from radians to degrees.
double	pcl::deg2rad (double alpha)
	Convert an angle from degrees to radians.
template<typename real >
real	pcl::normAngle (real alpha)
	Normalize an angle to (-PI, PI].
template<typename PointT >
void	pcl::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	pcl::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	pcl::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	pcl::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.
template<typename PointT >
void	pcl::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.
template<typename PointT >
void	pcl::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.
template<typename PointT >
void	pcl::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.
template<typename PointT >
void	pcl::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.
template<typename PointT >
void	pcl::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.
template<typename PointT >
void	pcl::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.
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)
	Subtract a centroid from a point cloud and return the de-meaned representation.
template<typename PointT >
void	pcl::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	pcl::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	pcl::demeanPointCloud (const pcl::PointCloud< PointT > &cloud_in, const pcl::PointIndices &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	pcl::computeNDCentroid (const pcl::PointCloud< PointT > &cloud, Eigen::VectorXf &centroid)
	General, all purpose nD centroid estimation for a set of points using their indices.
template<typename PointT >
void	pcl::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	pcl::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.
double	pcl::getAngle3D (const Eigen::Vector4f &v1, const Eigen::Vector4f &v2)
	Compute the smallest angle between two vectors in the [ 0, PI ) interval in 3D.
void	pcl::getMeanStd (const std::vector< float > &values, double &mean, double &stddev)
	Compute both the mean and the standard deviation of an array of values.
template<typename PointT >
void	pcl::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.
template<typename PointT >
void	pcl::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.
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)
	Get the point at maximum distance from a given point and a given pointcloud.
template<typename PointT >
void	pcl::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.
template<typename PointT >
void	pcl::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	pcl::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	pcl::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 >
double	pcl::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.
template<typename PointT >
void	pcl::getMinMax (const PointT &histogram, int len, float &min_p, float &max_p)
	Get the minimum and maximum values on a point histogram.
PCL_EXPORTS void	pcl::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.
PCL_EXPORTS void	pcl::getMeanStdDev (const std::vector< float > &values, double &mean, double &stddev)
	Compute both the mean and the standard deviation of an array of values.
PCL_EXPORTS 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.
double	pcl::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)
double	pcl::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)
template<typename PointT >
double	pcl::getMaxSegment (const pcl::PointCloud< PointT > &cloud, PointT &pmin, PointT &pmax)
	Obtain the maximum segment in a given set of points, and return the minimum and maximum points.
template<typename PointT >
double	pcl::getMaxSegment (const pcl::PointCloud< PointT > &cloud, const std::vector< int > &indices, PointT &pmin, PointT &pmax)
	Obtain the maximum segment in a given set of points, and return the minimum and maximum points.
template<typename Scalar , typename Roots >
void	pcl::computeRoots2 (const Scalar &b, const Scalar &c, Roots &roots)
	Compute the roots of 2 scalars.
template<typename Matrix , typename Roots >
void	pcl::computeRoots (const Matrix &m, Roots &roots)
	Compute the roots of a matrix.
template<typename Matrix , typename Vector >
void	pcl::eigen33 (const Matrix &mat, typename Matrix::Scalar &eigenvalue, Vector &eigenvector)
	determines the eigenvector and eigenvalue of the smallest eigenvalue of the symmetric positive semi definite input matrix
template<typename Matrix , typename Vector >
void	pcl::eigen33 (const Matrix &mat, Vector &evals)
	determines the eigenvalues of the symmetric positive semi definite input matrix
template<typename Matrix , typename Vector >
void	pcl::eigen33 (const Matrix &mat, Matrix &evecs, Vector &evals)
	determines the eigenvalues and corresponding eigenvectors of the symmetric positive semi definite input matrix
template<typename Matrix >
Matrix::Scalar	pcl::invert3x3SymMatrix (const Matrix &matrix, Matrix &inverse)
	calculates the inverse of a 3x3 symmetric matrix.
void	pcl::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::Affine3f	pcl::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	pcl::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	pcl::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	pcl::getTransformationFromTwoUnitVectors (const Eigen::Vector3f &y_direction, const Eigen::Vector3f &z_axis, 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::Affine3f	pcl::getTransformationFromTwoUnitVectors (const Eigen::Vector3f &y_direction, const Eigen::Vector3f &z_axis)
	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	pcl::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)
void	pcl::getEulerAngles (const Eigen::Affine3f &t, float &roll, float &pitch, float &yaw)
	Extract the Euler angles (XYZ-convention) from the given transformation.
void	pcl::getTranslationAndEulerAngles (const Eigen::Affine3f &t, float &x, float &y, float &z, float &roll, float &pitch, float &yaw)
	Extract x,y,z and the Euler angles (XYZ-convention) from the given transformation.
void	pcl::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	pcl::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)
template<typename Derived >
void	pcl::saveBinary (const Eigen::MatrixBase< Derived > &matrix, std::ostream &file)
	Write a matrix to an output stream.
template<typename Derived >
void	pcl::loadBinary (Eigen::MatrixBase< Derived > &matrix, std::istream &file)
	Read a matrix from an input stream.
PCL_EXPORTS 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.
PCL_EXPORTS bool	pcl::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.
template<typename FloatVectorT >
float	pcl::selectNorm (FloatVectorT A, FloatVectorT B, int dim, NormType norm_type)
	Method that calculates any norm type available, based on the norm_type variable.
template<typename FloatVectorT >
float	pcl::L1_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the L1 norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::L2_Norm_SQR (FloatVectorT A, FloatVectorT B, int dim)
	Compute the squared L2 norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::L2_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the L2 norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::Linf_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the L-infinity norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::JM_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the JM norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::B_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the B norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::Sublinear_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the sublinear norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::CS_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the CS norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::Div_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the div norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::PF_Norm (FloatVectorT A, FloatVectorT B, int dim, float P1, float P2)
	Compute the PF norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::K_Norm (FloatVectorT A, FloatVectorT B, int dim, float P1, float P2)
	Compute the K norm of the vector between two points.
template<typename FloatVectorT >
float	pcl::KL_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the KL between two discrete probability density functions.
template<typename FloatVectorT >
float	pcl::HIK_Norm (FloatVectorT A, FloatVectorT B, int dim)
	Compute the HIK norm of the vector between two points.
template<typename PointT >
void	pcl::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	pcl::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	pcl::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	pcl::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	pcl::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	pcl::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 >
PointT	pcl::transformPoint (const PointT &point, const Eigen::Affine3f &transform)
	Transform a point with members x,y,z.
bool	pcl::isBetterCorrespondence (const Correspondence &pc1, const Correspondence &pc2)
	Comparator to enable us to sort a vector of PointCorrespondences according to their scores using std::sort (begin(), end(), isBetterCorrespondence);.

Typedef Documentation

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 146 of file point_types.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 158 of file point_types.h.

enum pcl::NormType

Enum that defines all the types of norms available.

Note:: Any new norm type should have its own enum value and its own case in the selectNorm () method

Enumerator:

L1
L2_SQR
L2
LINF
JM
B
SUBLINEAR
CS
DIV
PF
K
KL
HIK

Definition at line 52 of file norms.h.

Function Documentation

template<typename FloatVectorT >

float pcl::B_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 132 of file norms.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 46 of file centroid.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 84 of file centroid.hpp.

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 123 of file centroid.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 131 of file centroid.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 201 of file centroid.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 262 of file centroid.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 191 of file centroid.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 272 of file centroid.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 283 of file centroid.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 381 of file centroid.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 402 of file centroid.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 424 of file centroid.hpp.

template<typename Matrix , typename Roots >

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

Compute the roots of a matrix.

Parameters:

[in]	m	the matrix
[out]	roots	the output roots

Definition at line 127 of file eigen.h.

template<typename Scalar , typename Roots >

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

Compute the roots of 2 scalars.

Parameters:

[in]	b	the first scalar
[in]	c	the second scalar
[out]	roots	the output roots

Definition at line 108 of file eigen.h.

template<typename FloatVectorT >

float pcl::CS_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 161 of file norms.hpp.

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

Convert an angle from degrees to radians.

Parameters:

alpha the input angle (in degrees)

Definition at line 51 of file angles.hpp.

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

Convert an angle from degrees to radians.

Parameters:

alpha the input angle (in degrees)

Definition at line 61 of file angles.hpp.

template<typename PointT >

void pcl::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.

Parameters:

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

Definition at line 294 of file centroid.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
	)

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 307 of file centroid.hpp.

template<typename PointT >

void pcl::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.

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 334 of file centroid.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
	)

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 352 of file centroid.hpp.

template<typename PointT >

void pcl::demeanPointCloud	(	const pcl::PointCloud< PointT > &	cloud_in,
		const pcl::PointIndices &	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.

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 371 of file centroid.hpp.

template<typename FloatVectorT >

float pcl::Div_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 175 of file norms.hpp.

template<typename Matrix , typename Vector >

void pcl::eigen33	(	const Matrix &	mat,
		typename Matrix::Scalar &	eigenvalue,
		Vector &	eigenvector
	)		`[inline]`

determines the eigenvector and eigenvalue of the smallest eigenvalue of the symmetric positive semi definite input matrix

Parameters:

[in]	mat	symmetric positive semi definite input matrix
[out]	eigenvalue	the smallest eigenvalue
[out]	eigenvector	the eigenvector corresponding to the smallest eigenvalue

Note:: if the smallest eigenvalue is not unique, this function may return any eigenvector that is consistent to the eigenvalue.

Definition at line 199 of file eigen.h.

template<typename Matrix , typename Vector >

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

determines the eigenvalues of the symmetric positive semi definite input matrix

Parameters:

[in]	mat	symmetric positive semi definite input matrix
[out]	evals	resulting eigenvalues in ascending order

Definition at line 239 of file eigen.h.

template<typename Matrix , typename Vector >

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

determines the eigenvalues and corresponding eigenvectors of the symmetric positive semi definite input matrix

Parameters:

[in]	mat	symmetric positive semi definite input matrix
[out]	evecs	resulting eigenvalues in ascending order
[out]	evals	corresponding eigenvectors in correct order according to eigenvalues

Definition at line 251 of file eigen.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 45 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 353 of file common.hpp.

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:

[in]	t	the input transformation matrix
[in]	roll	the resulting roll angle
[in]	pitch	the resulting pitch angle
[in]	yaw	the resulting yaw angle

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 115 of file common.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 158 of file common.hpp.

template<typename PointT >

double pcl::getMaxSegment	(	const pcl::PointCloud< PointT > &	cloud,
		PointT &	pmin,
		PointT &	pmax
	)		`[inline]`

Obtain the maximum segment in a given set of points, and return the minimum and maximum points.

Parameters:

[in]	cloud	the point cloud dataset
[out]	pmin	the coordinates of the "minimum" point in cloud (one end of the segment)
[out]	pmax	the coordinates of the "maximum" point in cloud (the other end of the segment)

Returns:: the length of segment length

Definition at line 100 of file distances.h.

template<typename PointT >

double pcl::getMaxSegment	(	const pcl::PointCloud< PointT > &	cloud,
		const std::vector< int > &	indices,
		PointT &	pmin,
		PointT &	pmax
	)		`[inline]`

Obtain the maximum segment in a given set of points, and return the minimum and maximum points.

Parameters:

[in]	cloud	the point cloud dataset
[in]	indices	a set of point indices to use from cloud
[out]	pmin	the coordinates of the "minimum" point in cloud (one end of the segment)
[out]	pmax	the coordinates of the "maximum" point in cloud (the other end of the segment)

Returns:: the length of segment length

Definition at line 139 of file distances.h.

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 56 of file common.hpp.

PCL_EXPORTS void pcl::getMeanStdDev	(	const std::vector< float > &	values,
		double &	mean,
		double &	stddev
	)

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

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 370 of file common.hpp.

PCL_EXPORTS void pcl::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.

Parameters:

cloud	the cloud containing multi-dimensional histograms
idx	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

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 205 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 242 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 318 of file common.hpp.

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 280 of file common.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 72 of file common.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:

[in]	x	the input x translation
[in]	y	the input y translation
[in]	z	the input z translation
[in]	roll	the input roll angle
[in]	pitch	the input pitch angle
[in]	yaw	the input yaw angle
[out]	t	the resulting transformation matrix

Definition at line 106 of file eigen.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:

[in]	x	the input x translation
[in]	y	the input y translation
[in]	z	the input z translation
[in]	roll	the input roll angle
[in]	pitch	the input pitch angle
[in]	yaw	the input yaw angle

Returns:: the resulting transformation matrix

Definition at line 116 of file eigen.hpp.

void pcl::getTransformationFromTwoUnitVectors	(	const Eigen::Vector3f &	y_direction,
		const Eigen::Vector3f &	z_axis,
		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:

[in]	y_direction	the y direction
[in]	z_axis	the z-axis
[out]	transformation	the resultant 3D rotation

Definition at line 76 of file eigen.hpp.

Eigen::Affine3f pcl::getTransformationFromTwoUnitVectors	(	const Eigen::Vector3f &	y_direction,
		const Eigen::Vector3f &	z_axis
	)		`[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:

[in]	y_direction	the y direction
[in]	z_axis	the z-axis

Returns:: transformation the resultant 3D rotation

Definition at line 81 of file eigen.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:

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

Definition at line 88 of file eigen.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:

[in]	x_axis	the x-axis
[in]	y_direction	the y direction
[out]	transformation	the resultant 3D rotation

Definition at line 57 of file eigen.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:

[in]	x_axis	the x-axis
[in]	y_direction	the y direction

Returns:: the resulting 3D rotation

Definition at line 69 of file eigen.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:

[in]	z_axis	the z-axis
[in]	y_direction	the y direction
[out]	transformation	the resultant 3D rotation

Definition at line 38 of file eigen.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:

[in]	z_axis	the z-axis
[in]	y_direction	the y direction

Returns:: the resultant 3D rotation

Definition at line 50 of file eigen.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:

[in]	t	the input transformation matrix
[out]	x	the resulting x translation
[out]	y	the resulting y translation
[out]	z	the resulting z translation
[out]	roll	the resulting roll angle
[out]	pitch	the resulting pitch angle
[out]	yaw	the resulting yaw angle

Definition at line 96 of file eigen.hpp.

template<typename FloatVectorT >

float pcl::HIK_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 225 of file norms.hpp.

template<typename Matrix >

Matrix::Scalar pcl::invert3x3SymMatrix	(	const Matrix &	matrix,
		Matrix &	inverse
	)		`[inline]`

calculates the inverse of a 3x3 symmetric matrix.

Parameters:

[in]	matrix	matrix to be inverted
[out]	inverse	the resultant inverted matrix

Note:: only the upper triangular part is taken into account => non symmetric matrices will give wrong results

Returns:: determinant of the original matrix => if 0 no inverse exists => result is invalid

Definition at line 441 of file eigen.h.

bool pcl::isBetterCorrespondence	(	const Correspondence &	pc1,
		const Correspondence &	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 142 of file correspondence.h.

template<typename FloatVectorT >

float pcl::JM_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 120 of file norms.hpp.

template<typename FloatVectorT >

float pcl::K_Norm	(	FloatVectorT	A,
		FloatVectorT	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

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 200 of file norms.hpp.

template<typename FloatVectorT >

float pcl::KL_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 211 of file norms.hpp.

template<typename FloatVectorT >

float pcl::L1_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 80 of file norms.hpp.

template<typename FloatVectorT >

float pcl::L2_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 103 of file norms.hpp.

template<typename FloatVectorT >

float pcl::L2_Norm_SQR	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 90 of file norms.hpp.

PCL_EXPORTS 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

PCL_EXPORTS 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

PCL_EXPORTS bool pcl::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.

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

template<typename FloatVectorT >

float pcl::Linf_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 110 of file norms.hpp.

template<typename Derived >

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

Read a matrix from an input stream.

Parameters:

[out]	matrix	the resulting matrix, read from the input stream
[in,out]	file	the input stream

Definition at line 138 of file eigen.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 41 of file angles.hpp.

template<typename FloatVectorT >

float pcl::PF_Norm	(	FloatVectorT	A,
		FloatVectorT	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

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 189 of file norms.hpp.

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

Convert an angle from radians to degrees.

Parameters:

alpha the input angle (in radians)

Definition at line 46 of file angles.hpp.

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

Convert an angle from radians to degrees.

Parameters:

alpha the input angle (in radians)

Definition at line 56 of file angles.hpp.

template<typename Derived >

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

Write a matrix to an output stream.

Parameters:

[in]	matrix	the matrix to output
[out]	file	the output stream

Definition at line 124 of file eigen.hpp.

template<typename FloatVectorT >

float pcl::selectNorm	(	FloatVectorT	A,
		FloatVectorT	B,
		int	dim,
		NormType	norm_type
	)		`[inline]`

Method that calculates any norm type available, based on the norm_type variable.

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 42 of file norms.hpp.

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 69 of file distances.h.

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 85 of file distances.h.

template<typename FloatVectorT >

float pcl::Sublinear_Norm	(	FloatVectorT	A,
		FloatVectorT	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)

Note:: FloatVectorT is any type of vector with its values accessible via [ ]

Definition at line 149 of file norms.hpp.

template<typename PointT >

PointT pcl::transformPoint	(	const PointT &	point,
		const Eigen::Affine3f &	transform
	)		`[inline]`

Transform a point with members x,y,z.

Parameters:

[in]	point	the point to transform
[out]	transform	the transformation to apply

Returns:: the transformed point

Definition at line 286 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
	)

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:: Can be used with cloud_in equal to cloud_out

Definition at line 39 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
	)

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:: Can be used with cloud_in equal to cloud_out

Definition at line 79 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
	)

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:: Can be used with cloud_in equal to cloud_out

Definition at line 166 of file transforms.hpp.

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

Definition at line 259 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
	)

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:: Can be used with cloud_in equal to cloud_out

Definition at line 207 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

Definition at line 273 of file transforms.hpp.

Detailed Description

Overview

Requirements

Classes

Files

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation