Classes | Files | Typedefs | Enumerations | Functions

Module common


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.

History

Requirements

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::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::PointCorrespondence
 Representation of a (possible) correspondence between two points in two different coordinate frames (e.g. 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...
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::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::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::PPFSignature
 A point structure for storing the Point Pair Feature (PPF) 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::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...

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  intersections.h
 

Define line with line intersection functions.


file  norms.h
 

Define standard C methods to calculate different norms.


file  rigid_transforms.h
 

Define rigid transformation methods between two different data sets.


file  time.h
 

Define methods for measuring time spent in code blocks.


file  transform.h
 

Define some libeigen based transformation methods.


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::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).
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.
bool pcl::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 PointSource , typename PointTarget >
void pcl::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 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)
 Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
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)
 Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
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::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).
std::ostream & pcl::operator<< (std::ostream &os, const Eigen::Affine3f &m)
 Output operator for Tranform3f.
Eigen::Affine3f pcl::getRotationOnly (const Eigen::Affine3f &transformation)
 Get only the rotation part of the transformation.
Eigen::Vector3f pcl::getTranslation (const Eigen::Affine3f &transformation)
 Get only the translation part of the transformation.
void pcl::getInverse (const Eigen::Affine3f &transformation, Eigen::Affine3f &inverse_transformation)
 Get the inverse of an Eigen::Affine3f object.
Eigen::Affine3f pcl::getInverse (const Eigen::Affine3f &transformation)
 Get the inverse of an Eigen::Affine3f object.
template<typename PointType >
PointType pcl::transformXYZ (const Eigen::Affine3f &transformation, const PointType &point)
 Transform a point with members x,y,z.
template<typename PointCloudType >
void pcl::getTransformedPointCloud (const PointCloudType &input, const Eigen::Affine3f &transformation, PointCloudType &output)
 Transform each point in the given point cloud according to the given transformation.
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.

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


Enumeration Type Documentation

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

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 [ ]
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 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::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::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 370 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 391 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 413 of file centroid.hpp.

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 [ ]
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.

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.

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 306 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 333 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 351 of file centroid.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 293 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 [ ]
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 45 of file rigid_transforms.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 148 of file rigid_transforms.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,
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 interest points from indices_src
transformation_matrix the resultant transformation matrix

Definition at line 95 of file rigid_transforms.hpp.

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:
t the input transformation matrix
roll the resulting roll angle
pitch the resulting pitch angle
yaw the resulting yaw angle
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
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
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.

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

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.

Eigen::Affine3f pcl::getRotationOnly ( 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
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
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
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
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
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
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
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
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
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
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
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 [ ]
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 98 of file point_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 [ ]
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 [ ]
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 [ ]
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 [ ]
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 [ ]
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 [ ]
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 [ ]
template<typename Derived >
void pcl::loadBinary ( Eigen::MatrixBase< Derived > &  matrix,
std::istream &  file 
)

Read a matrix from an input stream.

Parameters:
matrix the resulting matrix, read from the input stream
file the input stream
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.

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 119 of file transform.h.

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 [ ]
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:
matrix the matrix to output
file the output stream
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 [ ]
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 [ ]
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