Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
pcl::_AxisA point structure representing an Axis using its normal coordinates. (SSE friendly)
pcl::_NormalA point structure representing normal coordinates and the surface curvature estimate. (SSE friendly)
pcl::tracking::_ParticleXYR
pcl::tracking::_ParticleXYRP
pcl::tracking::_ParticleXYRPY
pcl::tracking::_ParticleXYZR
pcl::tracking::_ParticleXYZRPY
pcl::_PointNormalA point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate. (SSE friendly)
pcl::_PointSurfelA 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
pcl::_PointWithRangeA point structure representing Euclidean xyz coordinates, padded with an extra range float
pcl::_PointWithScaleA point structure representing a 3-D position and scale
pcl::_PointWithViewpoint
pcl::_PointXYZ
pcl::_PointXYZHSV
pcl::_PointXYZIA point structure representing Euclidean xyz coordinates, and the intensity value
pcl::_PointXYZINormalA point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate
pcl::_PointXYZL
pcl::_PointXYZRGB
pcl::_PointXYZRGBAA point structure representing Euclidean xyz coordinates, and the RGBA color
pcl::_PointXYZRGBL
pcl::_PointXYZRGBNormalA point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate. Due to historical reasons (PCL was first developed as a ROS package), the RGB information is packed into an integer and casted to a float. This is something we wish to remove in the near future, but in the meantime, the following code snippet should help you pack and unpack RGB colors in your PointXYZRGB structure:
pcl::_ReferenceFrameA structure representing the Local Reference Frame of a point
pcl::AdaptiveRangeCoderAdaptiveRangeCoder compression class
pcl::poisson::Octree< Degree >::AdjacencyCountFunction
pcl::poisson::OctNode< NodeData, Real >::AdjacencyCountFunction
pcl::poisson::Octree< Degree >::AdjacencySetFunction
pcl::poisson::Allocator< T >
pcl::poisson::AllocatorState
pcl::ApproximateVoxelGrid< PointT >ApproximateVoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::tracking::ApproxNearestPairPointCloudCoherence< PointInT >ApproxNearestPairPointCloudCoherence computes coherence between two pointclouds using the approximate nearest point pairs
pcl::traits::asEnum< T >
pcl::traits::asEnum< double >
pcl::traits::asEnum< float >
pcl::traits::asEnum< int16_t >
pcl::traits::asEnum< int32_t >
pcl::traits::asEnum< int8_t >
pcl::traits::asEnum< uint16_t >
pcl::traits::asEnum< uint32_t >
pcl::traits::asEnum< uint8_t >
pcl::traits::asType< int >
pcl::traits::asType< sensor_msgs::PointField::FLOAT32 >
pcl::traits::asType< sensor_msgs::PointField::FLOAT64 >
pcl::traits::asType< sensor_msgs::PointField::INT16 >
pcl::traits::asType< sensor_msgs::PointField::INT32 >
pcl::traits::asType< sensor_msgs::PointField::INT8 >
pcl::traits::asType< sensor_msgs::PointField::UINT16 >
pcl::traits::asType< sensor_msgs::PointField::UINT32 >
pcl::traits::asType< sensor_msgs::PointField::UINT8 >
pcl::Axis
pcl::BilateralFilter< PointT >A bilateral filter implementation for point cloud data. Uses the intensity data channel
pcl::BilateralUpsampling< PointInT, PointOutT >Bilateral filtering implementation, based on the following paper: * Kopf, Johannes and Cohen, Michael F. and Lischinski, Dani and Uyttendaele, Matt - Joint Bilateral Upsampling, * ACM Transations in Graphics, July 2007
pcl::poisson::BinaryNode< Real >
pcl::BivariatePolynomialT< real >This represents a bivariate polynomial and provides some functionality for it
pcl::BorderDescriptionA structure to store if a point in a range image lies on a border between an obstacle and the background
pcl::BoundaryA point structure representing a description of whether a point is lying on a surface boundary or not
pcl::BoundaryEstimation< PointInT, PointNT, PointOutT >BoundaryEstimation estimates whether a set of points is lying on surface boundaries using an angle criterion. The code makes use of the estimated surface normals at each point in the input dataset
pcl::BoundaryEstimation< PointInT, PointNT, Eigen::MatrixXf >BoundaryEstimation estimates whether a set of points is lying on surface boundaries using an angle criterion. The code makes use of the estimated surface normals at each point in the input dataset
pcl::search::BruteForce< PointT >Implementation of a simple brute force search algorithm
pcl::octree::BufferedBranchNode< ContainerT >
pcl::io::ply::ply_parser::scalar_property_definition_callbacks_type::callbacks_element< T >
pcl::io::ply::ply_parser::list_property_definition_callbacks_type::callbacks_element< T >
pcl::texture_mapping::CameraStructure to store camera pose and focal length
pcl::visualization::CameraCamera class holds a set of camera parameters together with the window pos/size
pcl::ChannelPropertiesChannelProperties stores the properties of each channel in a cloud, namely:
pcl::PCDWriter::ChannelPropertiesComparatorInternal structure used to sort the ChannelProperties in the cloud.channels map based on their offset
pcl::Clipper3D< PointT >Base class for 3D clipper objects
cloud_point_index_idx
pcl::cloud_show< CloudT >
pcl::cloud_show_base
pcl::visualization::CloudActor
pcl::CloudPropertiesCloudProperties stores a list of optional point cloud properties such as:
pcl::CloudSurfaceProcessing< PointInT, PointOutT >CloudSurfaceProcessing represents the base class for algorithms that take a point cloud as an input and produce a new output cloud that has been modified towards a better surface representation. These types of algorithms include surface smoothing, hole filling, cloud upsampling etc
pcl::visualization::CloudViewerSimple point cloud visualization class
pcl::visualization::CloudViewer::CloudViewer_impl
pcl::octree::ColorCoding< PointT >ColorCoding class
pcl::Comparator< PointT >Comparator is the base class for comparators that compare two points given some function. Currently intended for use with OrganizedConnectedComponentSegmentation
pcl::search::Search< PointT >::Compare
pcl::ComparisonBase< PointT >The (abstract) base class for the comparison object
pcl::ComputeFailedException
pcl::ConditionalRemoval< PointT >ConditionalRemoval filters data that satisfies certain conditions
pcl::ConditionAnd< PointT >AND condition
pcl::ConditionBase< PointT >Base condition class
pcl::ConditionOr< PointT >OR condition
ConditionThresholdHSV< PointT >
pcl::octree::configurationProfile_t
pcl::PointCloud< Eigen::MatrixXf >::CopyFieldsChannelProperties< T >Helper functor structure for copying channel information
pcl::CopyIfFieldExists< PointInT, OutT >A helper functor that can copy a specific value if the given field exists
pcl::poisson::CoredEdgeIndex
pcl::poisson::CoredFileMeshData
pcl::poisson::CoredMeshData
pcl::poisson::CoredPointIndex
pcl::poisson::CoredVectorMeshData
pcl::poisson::CoredVertexIndex
pcl::CorrespondenceCorrespondence represents a match between two entities (e.g., points, descriptors, etc). This is represesented via the indices of a source point and a target point, and the distance between them
pcl::registration::CorrespondenceEstimation< PointSource, PointTarget >CorrespondenceEstimation represents the base class for determining correspondences between target and query point sets/features
pcl::registration::CorrespondenceEstimationNormalShooting< PointSource, PointTarget, NormalT >CorrespondenceEstimationNormalShooting computes correspondences as points in the target cloud which have minimum distance to normals computed on the input cloud
pcl::registration::CorrespondenceRejector
pcl::registration::CorrespondenceRejectorDistance
pcl::registration::CorrespondenceRejectorFeatures
pcl::registration::CorrespondenceRejectorMedianDistance
pcl::registration::CorrespondenceRejectorOneToOneCorrespondenceRejectorOneToOne implements a correspondence rejection method based on eliminating duplicate match indices in the correspondences. Correspondences with the same match index are removed and only the one with smallest distance between query and match are kept. That is, considering match->query 1-m correspondences are removed leaving only 1-1 correspondences
pcl::registration::CorrespondenceRejectorSampleConsensus< PointT >CorrespondenceRejectorSampleConsensus implements a correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers)
pcl::registration::CorrespondenceRejectorSurfaceNormal
pcl::registration::CorrespondenceRejectorTrimmedCorrespondenceRejectorTrimmed implements a correspondence rejection for ICP-like registration algorithms that uses only the best 'k' correspondences where 'k' is some estimate of the overlap between the two point clouds being registered
pcl::registration::CorrespondenceRejectorVarTrimmed
pcl::CropBox< PointT >CropBox is a filter that allows the user to filter all the data inside of a given box
pcl::CropBox< sensor_msgs::PointCloud2 >CropBox is a filter that allows the user to filter all the data inside of a given box
pcl::CropHull< PointT >Filter points that lie inside or outside a 3D closed surface or 2D closed polygon, as generated by the ConvexHull or ConcaveHull classes
pcl::poisson::Cube
pcl::CustomPointRepresentation< PointDefault >CustomPointRepresentation extends PointRepresentation to allow for sub-part selection on the point
pcl::CVFHEstimation< PointInT, PointNT, PointOutT >CVFHEstimation estimates the Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in:
pcl::registration::DataContainer< PointT, NormalT >
pcl::registration::DataContainerInterface
pcl::traits::datatype< PointT, Tag >
pcl::traits::decomposeArray< T >
pcl::DefaultFeatureRepresentation< PointDefault >DefaulFeatureRepresentation extends PointRepresentation and is intended to be used when defining the default behavior for feature descriptor types (i.e., copy each element of each field into a float array)
pcl::DefaultPointRepresentation< PointDefault >DefaultPointRepresentation extends PointRepresentation to define default behavior for common point types
pcl::DefaultPointRepresentation< FPFHSignature33 >
pcl::DefaultPointRepresentation< NormalBasedSignature12 >
pcl::DefaultPointRepresentation< PFHRGBSignature250 >
pcl::DefaultPointRepresentation< PFHSignature125 >
pcl::DefaultPointRepresentation< PointNormal >
pcl::DefaultPointRepresentation< PointXYZ >
pcl::DefaultPointRepresentation< PointXYZI >
pcl::DefaultPointRepresentation< PPFSignature >
pcl::DefaultPointRepresentation< ShapeContext >
pcl::DefaultPointRepresentation< SHOT1344 >
pcl::DefaultPointRepresentation< SHOT352 >
pcl::DefaultPointRepresentation< VFHSignature308 >
pcl::tracking::DistanceCoherence< PointInT >DistanceCoherence computes coherence between two points from the distance between them. the coherence is calculated by 1 / (1 + weight * d^2 )
pcl::poisson::Octree< Degree >::DivergenceFunction
pcl::apps::DominantPlaneSegmentation< PointType >DominantPlaneSegmentation performs euclidean segmentation on a scene assuming that a dominant plane exists
pcl::GreedyProjectionTriangulation< PointInT >::doubleEdgeStruct for storing the edges starting from a fringe point
Dummy
pcl::EarClippingThe ear clipping triangulation algorithm. The code is inspired by Flavien Brebion implementation, which is in n^3 and does not handle holes
pcl::poisson::Edge
pcl::EdgeAwarePlaneComparator< PointT, PointNT >EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data
pcl::poisson::EdgeIndex
pcl::registration::ELCH< PointT >ELCH (Explicit Loop Closing Heuristic) class
pcl::io::ply::ply_parser::element
pcl::search::BruteForce< PointT >::Entry
pcl::search::OrganizedNeighbor< PointT >::Entry
pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::ErrorFunctor
pcl::ESFEstimation< PointInT, PointOutT >ESFEstimation estimates the ensemble of shape functions descriptors for a given point cloud dataset containing points. Shape functions are D2, D3, A3. For more information about the ESF descriptor, see: Walter Wohlkinger and Markus Vincze, "Ensemble of Shape Functions for 3D Object Classification", IEEE International Conference on Robotics and Biomimetics (IEEE-ROBIO), 2011
pcl::ESFSignature640A point structure representing the Ensemble of Shape Functions (ESF)
pcl::EuclideanClusterComparator< PointT, PointNT, PointLT >EuclideanClusterComparator is a comparator used for finding clusters supported by planar surfaces. This needs to be run as a second pass after extracting planar surfaces, using MultiPlaneSegmentation for example
pcl::EuclideanClusterExtraction< PointT >EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense
pcl::EuclideanPlaneCoefficientComparator< PointT, PointNT >EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data
EventHelper
pcl::visualization::PCLHistogramVisualizer::ExitCallback
pcl::visualization::ImageViewer::ExitCallback
pcl::visualization::PCLVisualizer::ExitCallback
pcl::visualization::Window::ExitCallback
pcl::visualization::PCLHistogramVisualizer::ExitMainLoopTimerCallback
pcl::visualization::ImageViewer::ExitMainLoopTimerCallback
pcl::visualization::PCLVisualizer::ExitMainLoopTimerCallback
pcl::visualization::Window::ExitMainLoopTimerCallback
pcl::ExtractIndices< PointT >ExtractIndices extracts a set of indices from a point cloud
pcl::ExtractIndices< sensor_msgs::PointCloud2 >ExtractIndices extracts a set of indices from a point cloud.
Usage examples:
pcl::ExtractPolygonalPrismData< PointT >ExtractPolygonalPrismData uses a set of point indices that represent a planar model, and together with a given height, generates a 3D polygonal prism. The polygonal prism is then used to segment all points lying inside it
pcl::poisson::Octree< Degree >::FaceEdgesFunction
pcl::Feature< PointInT, PointOutT >Feature represents the base feature class. Some generic 3D operations that are applicable to all features are defined here as static methods
FeatureCloud
pcl::registration::CorrespondenceRejectorFeatures::FeatureContainer< FeatureT >An inner class containing pointers to the source and target feature clouds and the parameters needed to perform the correspondence search. This class extends FeatureContainerInterface, which contains abstract methods for any methods that do not depend on the FeatureT --- these methods can thus be called from a pointer to FeatureContainerInterface without casting to the derived class
pcl::registration::CorrespondenceRejectorFeatures::FeatureContainerInterface
pcl::FeatureFromLabels< PointInT, PointLT, PointOutT >
pcl::FeatureFromNormals< PointInT, PointNT, PointOutT >
pcl::Narf::FeaturePointRepresentation
pcl::FeatureWithLocalReferenceFrames< PointInT, PointRFT >FeatureWithLocalReferenceFrames provides a public interface for descriptor extractor classes which need a local reference frame at each input keypoint
pcl::detail::FieldAdder< PointT >
pcl::FieldComparison< PointT >The field-based specialization of the comparison object
pcl::traits::fieldList< PointT >
pcl::detail::FieldMapper< PointT >
pcl::detail::FieldMapping
pcl::FieldMatches< PointT, Tag >
pcl::octree::OctreeBreadthFirstIterator< DataT, OctreeT >::FIFOElement
pcl::FileReaderPoint Cloud Data (FILE) file format reader interface. Any (FILE) format file reader should implement its virtual methodes
pcl::FileWriterPoint Cloud Data (FILE) file format writer. Any (FILE) format file reader should implement its virtual methodes
pcl::Filter< PointT >Filter represents the base filter class. All filters must inherit from this interface
pcl::Filter< sensor_msgs::PointCloud2 >Filter represents the base filter class. All filters must inherit from this interface
pcl::FilterIndices< PointT >FilterIndices represents the base class for filters that are about binary point removal.
All derived classes have to implement the filter (PointCloud &output) and the filter (std::vector<int> &indices) methods. Ideally they also make use of the negative_, keep_organized_ and extract_removed_indices_ systems. The distinguishment between the negative_ and extract_removed_indices_ systems only makes sense if the class automatically filters non-finite entries in the filtering methods (recommended)
pcl::FilterIndices< sensor_msgs::PointCloud2 >FilterIndices represents the base class for filters that are about binary point removal.
All derived classes have to implement the filter (PointCloud &output) and the filter (std::vector<int> &indices) methods. Ideally they also make use of the negative_, keep_organized_ and extract_removed_indices_ systems. The distinguishment between the negative_ and extract_removed_indices_ systems only makes sense if the class automatically filters non-finite entries in the filtering methods (recommended)
pcl::search::FlannSearch< PointT, FlannDistance >::FlannIndexCreatorHelper class that creates a FLANN index from a given FLANN matrix. To use a FLANN index type with FlannSearch, implement this interface and pass an object of the new type to the FlannSearch constructor. See the implementation of KdTreeIndexCreator for an example
pcl::search::FlannSearch< PointT, FlannDistance >search::FlannSearch is a generic FLANN wrapper class for the new search interface. It is able to wrap any FLANN index type, e.g. the kd tree as well as indices for high-dimensional searches and intended as a more powerful and cleaner successor to KdTreeFlann
pcl::visualization::FloatImageUtils
pcl::for_each_type_impl< done >
pcl::for_each_type_impl< false >
pcl::FPFHEstimation< PointInT, PointNT, PointOutT >FPFHEstimation estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals
pcl::FPFHEstimation< PointInT, PointNT, Eigen::MatrixXf >FPFHEstimation estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals
pcl::FPFHEstimationOMP< PointInT, PointNT, PointOutT >FPFHEstimationOMP estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals, in parallel, using the OpenMP standard
pcl::FPFHSignature33A point structure representing the Fast Point Feature Histogram (FPFH)
pcl::visualization::FPSCallback
pcl::poisson::FunctionData< Degree, Real >
pcl::registration::TransformationEstimationLM< PointSource, PointTarget >::Functor< _Scalar, NX, NY >
pcl::Functor< _Scalar, NX, NY >
pcl::GaussianKernel
pcl::GeneralizedIterativeClosestPoint< PointSource, PointTarget >GeneralizedIterativeClosestPoint is an ICP variant that implements the generalized iterative closest point algorithm as described by Alex Segal et al. in http://www.stanford.edu/~avsegal/resources/papers/Generalized_ICP.pdf The approach is based on using anistropic cost functions to optimize the alignment after closest point assignments have been made. The original code uses GSL and ANN while in ours we use an eigen mapped BFGS and FLANN
pcl::GFPFHSignature16A point structure representing the GFPFH descriptor with 16 bins
pcl::GrabberGrabber interface for PCL 1.x device drivers
pcl::GreedyProjectionTriangulation< PointInT >GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points based on local 2D projections. It assumes locally smooth surfaces and relatively smooth transitions between areas with different point densities
pcl::GridProjection< PointNT >Grid projection surface reconstruction method
pcl::HarrisKeypoint3D< PointInT, PointOutT, NormalT >HarrisKeypoint3D uses the idea of 2D Harris keypoints, but instead of using image gradients, it uses surface normals
__gnu_cxx::hash< const long long >
__gnu_cxx::hash< const unsigned long long >
__gnu_cxx::hash< long long >
__gnu_cxx::hash< unsigned long long >
pcl::PPFHashMapSearch::HashKeyStructData structure to hold the information for the key in the feature hash map of the PPFHashMapSearch class
pcl::ApproximateVoxelGrid< PointT >::he
pcl::DefaultFeatureRepresentation< PointDefault >::NdCopyPointFunctor::Helper< Key, FieldT, NrDims >
pcl::DefaultFeatureRepresentation< PointDefault >::NdCopyPointFunctor::Helper< Key, FieldT[NrDims], NrDims >
pcl::Histogram< N >A point structure representing an N-D histogram
pcl::tracking::HSVColorCoherence< PointInT >HSVColorCoherence computes coherence between the two points from the color difference between them. the color difference is calculated in HSV color space. the coherence is calculated by 1 / ( 1 + w * (w_h^2 * h_diff^2 + w_s^2 * s_diff^2 + w_v^2 * v_diff^2))
pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::HuberPenalty
ICCVTutorial< FeatureType >
pcl::visualization::ImageViewerImageViewer is a class for 2D image visualization
pcl::DefaultFeatureRepresentation< PointDefault >::IncrementFunctor
pcl::InitFailedExceptionAn exception thrown when init can not be performed should be used in all the PCLBase class inheritants
pcl::IntegralImage2D< DataType, Dimension >Determines an integral image representation for a given organized data array
pcl::IntegralImage2D< DataType, 1 >Partial template specialization for integral images with just one channel
pcl::IntegralImageNormalEstimation< PointInT, PointOutT >Surface normal estimation on organized data using integral images
pcl::IntegralImageTypeTraits< DataType >
pcl::IntegralImageTypeTraits< char >
pcl::IntegralImageTypeTraits< float >
pcl::IntegralImageTypeTraits< int >
pcl::IntegralImageTypeTraits< short >
pcl::IntegralImageTypeTraits< unsigned char >
pcl::IntegralImageTypeTraits< unsigned int >
pcl::IntegralImageTypeTraits< unsigned short >
pcl::common::IntensityFieldAccessor< PointT >
pcl::common::IntensityFieldAccessor< pcl::PointNormal >
pcl::common::IntensityFieldAccessor< pcl::PointXYZRGB >
pcl::common::IntensityFieldAccessor< pcl::PointXYZRGBA >
pcl::IntensityGradientA point structure representing the intensity gradient of an XYZI point cloud
pcl::IntensityGradientEstimation< PointInT, PointNT, PointOutT, IntensitySelectorT >IntensityGradientEstimation estimates the intensity gradient for a point cloud that contains position and intensity values. The intensity gradient at a given point will be a vector orthogonal to the surface normal and pointing in the direction of the greatest increase in local intensity; the vector's magnitude indicates the rate of intensity change
pcl::IntensityGradientEstimation< PointInT, PointNT, Eigen::MatrixXf >IntensityGradientEstimation estimates the intensity gradient for a point cloud that contains position and intensity values. The intensity gradient at a given point will be a vector orthogonal to the surface normal and pointing in the direction of the greatest increase in local intensity; the vector's magnitude indicates the rate of intensity change
pcl::IntensitySpinEstimation< PointInT, PointOutT >IntensitySpinEstimation estimates the intensity-domain spin image descriptors for a given point cloud dataset containing points and intensity. For more information about the intensity-domain spin image descriptor, see:
pcl::IntensitySpinEstimation< PointInT, Eigen::MatrixXf >IntensitySpinEstimation estimates the intensity-domain spin image descriptors for a given point cloud dataset containing points and intensity. For more information about the intensity-domain spin image descriptor, see:
pcl::InterestPointA point structure representing an interest point with Euclidean xyz coordinates, and an interest value
pcl::intersect< Sequence1, Sequence2 >
pcl::InvalidConversionExceptionAn exception that is thrown when a PointCloud2 message cannot be converted into a PCL type
pcl::InvalidSACModelTypeExceptionAn exception that is thrown when a sample consensus model doesn't have the correct number of samples defined in model_types.h
pcl::IOExceptionAn exception that is thrown during an IO error (typical read/write errors)
openni_wrapper::IRImageClass containing just a reference to IR meta data
pcl::PosesFromMatches::PoseEstimate::IsBetter
pcl::IsNotDenseExceptionAn exception that is thrown when a PointCloud is not dense but is attemped to be used as dense
pcl::IterativeClosestPoint< PointSource, PointTarget >IterativeClosestPoint provides a base implementation of the Iterative Closest Point algorithm. The transformation is estimated based on Singular Value Decomposition (SVD)
pcl::IterativeClosestPointNonLinear< PointSource, PointTarget >IterativeClosestPointNonLinear is an ICP variant that uses Levenberg-Marquardt optimization backend. The resultant transformation is optimized as a quaternion
pcl::KdTree< PointT >KdTree represents the base spatial locator class for kd-tree implementations
pcl::search::KdTree< PointT >search::KdTree is a wrapper class which inherits the pcl::KdTree class for performing search functions using KdTree structure. KdTree is a generic type of 3D spatial locator using kD-tree structures. The class is making use of the FLANN (Fast Library for Approximate Nearest Neighbor) project by Marius Muja and David Lowe
pcl::KdTreeFLANN< PointT, Dist >KdTreeFLANN is a generic type of 3D spatial locator using kD-tree structures. The class is making use of the FLANN (Fast Library for Approximate Nearest Neighbor) project by Marius Muja and David Lowe
pcl::KdTreeFLANN< Eigen::MatrixXf >KdTreeFLANN is a generic type of 3D spatial locator using kD-tree structures. The class is making use of the FLANN (Fast Library for Approximate Nearest Neighbor) project by Marius Muja and David Lowe
pcl::search::FlannSearch< PointT, FlannDistance >::KdTreeIndexCreatorCreates a FLANN KdTreeSingleIndex from the given input data
pcl::KernelWidthTooSmallExceptionAn exception that is thrown when the kernel size is too small
pcl::visualization::KeyboardEvent
pcl::Keypoint< PointInT, PointOutT >Keypoint represents the base class for key points
KeypointT
pcl::tracking::KLDAdaptiveParticleFilterOMPTracker< PointInT, StateT >KLDAdaptiveParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method. The number of the particles changes adaptively based on KLD sampling [D. Fox, NIPS-01], [D.Fox, IJRR03]. and the computation of the weights of the particles is parallelized using OpenMP
pcl::tracking::KLDAdaptiveParticleFilterTracker< PointInT, StateT >KLDAdaptiveParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method. The number of the particles changes adaptively based on KLD sampling [D. Fox, NIPS-01], [D.Fox, IJRR03]
pcl::Label
pcl::LabeledEuclideanClusterExtraction< PointT >LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info
pcl::poisson::Octree< Degree >::LaplacianMatrixFunction
pcl::poisson::Octree< Degree >::LaplacianProjectionFunction
pcl::visualization::ImageViewer::LayerInternal structure describing a layer
pcl::visualization::ImageViewer::LayerComparator
pcl::UniformSampling< PointInT >::LeafSimple structure to hold an nD centroid and the number of points in a leaf
pcl::GridProjection< PointNT >::LeafData leaf
pcl::MovingLeastSquares< PointInT, PointOutT >::MLSVoxelGrid::Leaf
pcl::LeastMedianSquares< PointT >LeastMedianSquares represents an implementation of the LMedS (Least Median of Squares) algorithm. LMedS is a RANSAC-like model-fitting algorithm that can tolerate up to 50% outliers without requiring thresholds to be set. See Andrea Fusiello's "Elements of Geometric Computer Vision" (http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/FUSIELLO4/tutorial.html#x1-520007) for more details
pcl::LineIteratorOrganized Index Iterator for iterating over the "pixels" for a given line using the Bresenham algorithm. Supports 4 and 8 neighborhood connectivity
pcl::io::ply::ply_parser::list_property< SizeType, ScalarType >
pcl::io::ply::ply_parser::list_property_begin_callback_type< SizeType, ScalarType >
pcl::io::ply::ply_parser::list_property_definition_callback_type< SizeType, ScalarType >
pcl::io::ply::ply_parser::list_property_definition_callbacks_type
pcl::io::ply::ply_parser::list_property_element_callback_type< SizeType, ScalarType >
pcl::io::ply::ply_parser::list_property_end_callback_type< SizeType, ScalarType >
pcl::RangeImageBorderExtractor::LocalSurfaceStores some information extracted from the neighborhood of a point
pcl::MarchingCubes< PointNT >The marching cubes surface reconstruction algorithm. This is an abstract class that takes a grid and extracts the isosurface as a mesh, based on the original marching cubes paper:
pcl::poisson::MarchingCubes
pcl::MarchingCubesHoppe< PointNT >The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance from tangent planes, proposed by Hoppe et. al. in: Hoppe H., DeRose T., Duchamp T., MC-Donald J., Stuetzle W., "Surface reconstruction from unorganized points", SIGGRAPH '92
pcl::MarchingCubesRBF< PointNT >The marching cubes surface reconstruction algorithm, using a signed distance function based on radial basis functions. Partially based on: Carr J.C., Beatson R.K., Cherrie J.B., Mitchell T.J., Fright W.R., McCallum B.C. and Evans T.R., "Reconstruction and representation of 3D objects with radial basis functions" SIGGRAPH '01
pcl::poisson::MarchingSquares
pcl::poisson::MatrixEntry< T >
pcl::MaximumLikelihoodSampleConsensus< PointT >MaximumLikelihoodSampleConsensus represents an implementation of the MLESAC (Maximum Likelihood Estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S. Torr and A. Zisserman, Computer Vision and Image Understanding, vol 78, 2000
Mesh
pcl::MeshConstruction< PointInT >MeshConstruction represents a base surface reconstruction class. All mesh constructing methods that take in a point cloud and generate a surface that uses the original data as vertices should inherit from this class
pcl::MeshProcessingMeshProcessing represents the base class for mesh processing algorithms
pcl::MeshSmoothingLaplacianVTKPCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library. Please check out the original documentation for more details on the inner workings of the algorithm Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh data structure to the vtkPolyData data structure and back
pcl::MeshSmoothingWindowedSincVTKPCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library. Please check out the original documentation for more details on the inner workings of the algorithm Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh data structure to the vtkPolyData data structure and back
pcl::MeshSubdivisionVTKPCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library. Please check out the original documentation for more details on the inner workings of the algorithm Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh data structure to the vtkPolyData data structure and back
pcl::MEstimatorSampleConsensus< PointT >MEstimatorSampleConsensus represents an implementation of the MSAC (M-estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S. Torr and A. Zisserman, Computer Vision and Image Understanding, vol 78, 2000
pcl::MovingLeastSquares< PointInT, PointOutT >::MLSResultData structure used to store the results of the MLS fitting
pcl::MovingLeastSquares< PointInT, PointOutT >::MLSVoxelGridA minimalistic implementation of a voxel grid, necessary for the point cloud upsampling
pcl::MomentInvariantsA point structure representing the three moment invariants
pcl::MomentInvariantsEstimation< PointInT, PointOutT >MomentInvariantsEstimation estimates the 3 moment invariants (j1, j2, j3) at each 3D point
pcl::MomentInvariantsEstimation< PointInT, Eigen::MatrixXf >MomentInvariantsEstimation estimates the 3 moment invariants (j1, j2, j3) at each 3D point
pcl::visualization::MouseEvent
pcl::MovingLeastSquares< PointInT, PointOutT >MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm for data smoothing and improved normal estimation. It also contains methods for upsampling the resulting cloud based on the parametric fit. Reference paper: "Computing and Rendering Point Set Surfaces" by Marc Alexa, Johannes Behr, Daniel Cohen-Or, Shachar Fleishman, David Levin and Claudio T. Silva www.sci.utah.edu/~shachar/Publications/crpss.pdf
pcl::MovingLeastSquaresOMP< PointInT, PointOutT >MovingLeastSquaresOMP represent an OpenMP implementation of the MLS (Moving Least Squares) algorithm for data smoothing and improved normal estimation
pcl::MultiscaleFeaturePersistence< PointSource, PointFeature >Generic class for extracting the persistent features from an input point cloud It can be given any Feature estimator instance and will compute the features of the input over a multiscale representation of the cloud and output the unique ones over those scales
MyPoint
MyPointRepresentationXY
pcl::traits::name< PointT, Tag, dummy >
pcl::NarfNARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data. Please refer to pcl/features/narf_descriptor.h if you want the class derived from pcl Feature
pcl::Narf36A point structure representing the Narf descriptor
pcl::NarfDescriptor
pcl::NarfKeypointNARF (Normal Aligned Radial Feature) keypoints. Input is a range image, output the indices of the keypoints
pcl::NdCentroidFunctor< PointT >Helper functor structure for n-D centroid estimation
pcl::NdConcatenateFunctor< PointInT, PointOutT >Helper functor structure for concatenate
pcl::NdCopyEigenPointFunctor< PointOutT >Helper functor structure for copying data between an Eigen type and a PointT
pcl::PointCloud< Eigen::MatrixXf >::NdCopyEigenPointFunctor< PointOutT, PointInT >Helper functor structure for copying data between an Eigen type and a PointT
pcl::NdCopyPointEigenFunctor< PointInT >Helper functor structure for copying data between an Eigen type and a PointT
pcl::PointCloud< Eigen::MatrixXf >::NdCopyPointEigenFunctor< PointInT, PointOutT >Helper functor structure for copying data between an Eigen type and a PointT
pcl::DefaultFeatureRepresentation< PointDefault >::NdCopyPointFunctor
pcl::tracking::NearestPairPointCloudCoherence< PointInT >NearestPairPointCloudCoherence computes coherence between two pointclouds using the nearest point pairs
pcl::OrganizedConnectedComponentSegmentation< PointT, PointLT >::Neighbor
pcl::poisson::OctNode< NodeData, Real >::NeighborKey
pcl::poisson::OctNode< NodeData, Real >::NeighborKey2
pcl::poisson::OctNode< NodeData, Real >::Neighbors
pcl::poisson::OctNode< NodeData, Real >::Neighbors2
NILinemod
pcl::poisson::NMatrixEntry< T, Dim >
pcl::GreedyProjectionTriangulation< PointInT >::nnAngleStruct for storing the angles to nearest neighbors
pcl::NNClassification< PointT >Nearest neighbor search based classification of PCL point type features. FLANN is used to identify a neighborhood, based on which different scoring schemes can be employed to obtain likelihood values for a specified list of classes
pcl::Normal
pcl::NormalBasedSignature12A point structure representing the Normal Based Signature for a feature matrix of 4-by-3
pcl::NormalBasedSignatureEstimation< PointT, PointNT, PointFeature >Normal-based feature signature estimation class. Obtains the feature vector by applying Discrete Cosine and Fourier Transforms on an NxM array of real numbers representing the projection distances of the points in the input cloud to a disc around the point of interest. Please consult the following publication for more details: Xinju Li and Igor Guskov Multi-scale features for approximate alignment of point-based surfaces Proceedings of the third Eurographics symposium on Geometry processing July 2005, Vienna, Austria
pcl::tracking::NormalCoherence< PointInT >NormalCoherence computes coherence between two points from the angle between their normals. the coherence is calculated by 1 / (1 + weight * theta^2 )
pcl::NormalEstimation< PointInT, PointOutT >NormalEstimation estimates local surface properties (surface normals and curvatures)at each 3D point. If PointOutT is specified as pcl::Normal, the normal is stored in the first 3 components (0-2), and the curvature is stored in component 3
pcl::NormalEstimation< PointInT, Eigen::MatrixXf >NormalEstimation estimates local surface properties at each 3D point, such as surface normals and curvatures
pcl::NormalEstimationOMP< PointInT, PointOutT >NormalEstimationOMP estimates local surface properties at each 3D point, such as surface normals and curvatures, in parallel, using the OpenMP standard
pcl::NormalEstimationOMP< PointInT, Eigen::MatrixXf >NormalEstimationOMP estimates local surface properties at each 3D point, such as surface normals and curvatures, in parallel, using the OpenMP standard
pcl::NormalSpaceSampling< PointT, NormalT >NormalSpaceSampling samples the input point cloud in the space of normal directions computed at every point
pcl::NotEnoughPointsExceptionAn exception that is thrown when the number of correspondants is not equal to the minimum required
pcl::poisson::NVector< T, Dim >
ObjectFeatures
ObjectModel
ObjectRecognition
ObjectRecognitionParameters
pcl::poisson::OctNode< NodeData, Real >
pcl::search::Octree< PointT, LeafTWrap, BranchTWrap, OctreeT >search::Octree is a wrapper class which implements nearest neighbor search operations based on the pcl::octree::Octree structure
pcl::poisson::Octree< Degree >
pcl::octree::Octree2BufBase< DataT, LeafT, BranchT >Octree double buffer class
pcl::octree::OctreeBase< DataT, LeafT, BranchT >Octree class
pcl::octree::OctreeBranchNode< ContainerT >Abstract octree branch class
pcl::octree::OctreeBreadthFirstIterator< DataT, OctreeT >Octree iterator class
pcl::octree::OctreeContainerDataT< DataT >Octree leaf class that does store a single DataT element
pcl::octree::OctreeContainerDataTVector< DataT >Octree leaf class that does store a vector of DataT elements
pcl::octree::OctreeContainerEmpty< DataT >Octree leaf class that does not store any information
pcl::octree::OctreeDepthFirstIterator< DataT, OctreeT >Octree iterator class
pcl::octree::OctreeIteratorBase< DataT, OctreeT >Abstract octree iterator class
pcl::octree::OctreeKeyOctree key class
pcl::octree::OctreeLeafNode< ContainerT >Abstract octree leaf class
pcl::octree::OctreeLeafNodeIterator< DataT, OctreeT >Octree leaf node iterator class
pcl::octree::OctreeNodeAbstract octree node class
pcl::octree::OctreeNodePool< NodeT >Octree node pool
pcl::octree::OctreePointCloud< PointT, LeafT, BranchT, OctreeT >Octree pointcloud class
pcl::octree::OctreePointCloudChangeDetector< PointT, LeafT, BranchT >Octree pointcloud change detector class
pcl::octree::OctreePointCloudDensity< PointT, LeafT, BranchT >Octree pointcloud density class
pcl::octree::OctreePointCloudDensityContainer< DataT >Octree pointcloud density leaf node class
pcl::octree::OctreePointCloudOccupancy< PointT, LeafT, BranchT >Octree pointcloud occupancy class
pcl::octree::OctreePointCloudPointVector< PointT, LeafT, BranchT, OctreeT >Octree pointcloud point vector class
pcl::octree::OctreePointCloudSearch< PointT, LeafT, BranchT >Octree pointcloud search class
pcl::octree::OctreePointCloudSinglePoint< PointT, LeafT, BranchT, OctreeT >Octree pointcloud single point class
pcl::octree::OctreePointCloudVoxelCentroid< PointT, LeafT, BranchT >Octree pointcloud voxel centroid class
OctreeViewer
pcl::traits::offset< PointT, Tag >
OpenNI3DConcaveHull< PointType >
OpenNI3DConvexHull< PointType >
OpenNICapture
OpenNIChangeViewer
OpenNIFastMesh< PointType >
OpenNIFeaturePersistence< PointType >
OpenNIGrabFrame< PointType >
OpenNIIntegralImageNormalEstimation< PointType >
OpenNIIO< PointType >
OpenNIOrganizedMultiPlaneSegmentation
OpenNIPassthrough< PointType >
OpenNIPlanarSegmentation< PointType >
OpenNISegmentTracking< PointType >
OpenNISmoothing< PointType >
OpenNIUniformSampling
OpenNIVoxelGrid< PointType >
pcl::registration::TransformationEstimationLM< PointSource, PointTarget >::OptimizationFunctor
pcl::SampleConsensusModelCircle2D< PointT >::OptimizationFunctorFunctor for the optimization function
pcl::SampleConsensusModelCone< PointT, PointNT >::OptimizationFunctorFunctor for the optimization function
pcl::SampleConsensusModelCylinder< PointT, PointNT >::OptimizationFunctorFunctor for the optimization function
pcl::SampleConsensusModelSphere< PointT >::OptimizationFunctor
pcl::GeneralizedIterativeClosestPoint< PointSource, PointTarget >::OptimizationFunctorWithIndicesOptimization functor structure
pcl::registration::TransformationEstimationLM< PointSource, PointTarget >::OptimizationFunctorWithIndices
pcl::OrganizedConnectedComponentSegmentation< PointT, PointLT >OrganizedConnectedComponentSegmentation allows connected components to be found within organized point cloud data, given a comparison function. Given an input cloud and a comparator, it will output a PointCloud of labels, giving each connected component a unique id, along with a vector of PointIndices corresponding to each component. See OrganizedMultiPlaneSegmentation for an example application
pcl::OrganizedFastMesh< PointInT >Simple triangulation/surface reconstruction for organized point clouds. Neighboring points (pixels in image space) are connected to construct a triangular mesh
pcl::OrganizedIndexIteratorBase class for iterators on 2-dimensional maps like images/organized clouds etc
pcl::OrganizedMultiPlaneSegmentation< PointT, PointNT, PointLT >OrganizedMultiPlaneSegmentation finds all planes present in the input cloud, and outputs a vector of plane equations, as well as a vector of point clouds corresponding to the inliers of each detected plane. Only planes with more than min_inliers points are detected. Templated on point type, normal type, and label type
pcl::search::OrganizedNeighbor< PointT >OrganizedNeighbor is a class for optimized nearest neigbhor search in organized point clouds
OrganizedSegmentationDemo
pcl::PackedHSIComparison< PointT >A packed HSI specialization of the comparison object
pcl::PackedRGBComparison< PointT >A packed rgb specialization of the comparison object
pcl::io::ply::ply_parser::list_property_definition_callbacks_type::pair_with< T >
pcl::RangeImageBorderExtractor::ParametersParameters used in this class
pcl::NarfDescriptor::Parameters
pcl::PolynomialCalculationsT< real >::ParametersParameters used in this class
pcl::PosesFromMatches::ParametersParameters used in this class
pcl::NarfKeypoint::ParametersParameters used in this class
pcl::tracking::ParticleFilterOMPTracker< PointInT, StateT >ParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method in parallel, using the OpenMP standard
pcl::tracking::ParticleFilterTracker< PointInT, StateT >ParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
pcl::tracking::ParticleXYR
pcl::tracking::ParticleXYRP
pcl::tracking::ParticleXYRPY
pcl::tracking::ParticleXYZR
pcl::tracking::ParticleXYZRPY
pcl::PassThrough< PointT >PassThrough passes points in a cloud based on constraints for one particular field of the point type
pcl::PassThrough< sensor_msgs::PointCloud2 >PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints
pcl::PCA< PointT >
pcl::PCDGrabber< PointT >
pcl::PCDGrabberBaseBase class for PCD file grabber
pcl::PCDGrabberBase::PCDGrabberImpl
PCDOrganizedMultiPlaneSegmentation< PointT >
pcl::PCDReaderPoint Cloud Data (PCD) file format reader
pcl::PCDWriterPoint Cloud Data (PCD) file format writer
pcl::PCLBase< PointT >PCL base class. Implements methods that are used by all PCL objects
pcl::PCLBase< sensor_msgs::PointCloud2 >
pcl::PCLExceptionA base class for all pcl exceptions which inherits from std::runtime_error
pcl::visualization::PCLHistogramVisualizerPCL histogram visualizer main class
pcl::visualization::PCLHistogramVisualizerInteractorStylePCL histogram visualizer interactory style class
pcl::visualization::PCLImageCanvasSource2DPclImageCanvasSource2D represents our own custom version of vtkImageCanvasSource2D, used by the ImageViewer class
pcl::PCLIOExceptionBase exception class for I/O operations
PCLMobileServer< PointType >
pcl::PCLSurfaceBase< PointInT >Pure abstract class. All types of meshing/reconstruction algorithms in libpcl_surface must inherit from this, in order to make sure we have a consistent API. The methods that we care about here are:
pcl::visualization::PCLVisualizerPCL Visualizer main class
pcl::visualization::PCLVisualizerInteractorThe PCLVisualizer interactor
pcl::visualization::PCLVisualizerInteractorStylePCLVisualizerInteractorStyle defines an unique, custom VTK based interactory style for PCL Visualizer applications. Besides defining the rendering style, we also create a list of custom actions that are triggered on different keys being pressed:
pcl::PFHEstimation< PointInT, PointNT, PointOutT >PFHEstimation estimates the Point Feature Histogram (PFH) descriptor for a given point cloud dataset containing points and normals
pcl::PFHEstimation< PointInT, PointNT, Eigen::MatrixXf >PFHEstimation estimates the Point Feature Histogram (PFH) descriptor for a given point cloud dataset containing points and normals
pcl::PFHRGBEstimation< PointInT, PointNT, PointOutT >
pcl::PFHRGBSignature250A point structure representing the Point Feature Histogram with colors (PFHRGB)
pcl::PFHSignature125A point structure representing the Point Feature Histogram (PFH)
pcl::PiecewiseLinearFunctionThis provides functionalities to efficiently return values for piecewise linear function
pcl::PlanarPolygon< PointT >PlanarPolygon represents a planar (2D) polygon, potentially in a 3D space
pcl::PlanarPolygonFusion< PointT >PlanarPolygonFusion takes a list of 2D planar polygons and attempts to reduce them to a minimum set that best represents the scene, based on various given comparators
pcl::PlanarRegion< PointT >PlanarRegion represents a set of points that lie in a plane. Inherits summary statistics about these points from Region3D, and summary statistics of a 3D collection of points
pcl::PlaneClipper3D< PointT >Implementation of a plane clipper in 3D
pcl::PlaneCoefficientComparator< PointT, PointNT >PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data
pcl::PlaneRefinementComparator< PointT, PointNT, PointLT >PlaneRefinementComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data
PlaneSegTest
Player
pcl::io::ply::ply_parser
ply_to_obj_converter
ply_to_ply_converter
ply_to_raw_converter
pcl::PLYReaderPoint Cloud Data (PLY) file format reader
pcl::PLYWriterPoint Cloud Data (PLY) file format writer
pcl::traits::POD< PointT >
pcl::poisson::Point3D< Real >
pcl::PointCloud< PointT >PointCloud represents the base class in PCL for storing collections of 3D points
pcl::PointCloud< Eigen::MatrixXf >PointCloud specialization for Eigen matrices. For advanced users only!
PointCloudBuffers
pcl::tracking::PointCloudCoherence< PointInT >PointCloudCoherence is a base class to compute coherence between the two PointClouds
pcl::visualization::PointCloudColorHandler< PointT >Base Handler class for PointCloud colors
pcl::visualization::PointCloudColorHandler< sensor_msgs::PointCloud2 >Base Handler class for PointCloud colors
pcl::visualization::PointCloudColorHandlerCustom< PointT >Handler for predefined user colors. The color at each point will be drawn as the use given R, G, B values
pcl::visualization::PointCloudColorHandlerCustom< sensor_msgs::PointCloud2 >Handler for predefined user colors. The color at each point will be drawn as the use given R, G, B values
pcl::visualization::PointCloudColorHandlerGenericField< PointT >Generic field handler class for colors. Uses an user given field to extract 1D data and display the color at each point using a min-max lookup table
pcl::visualization::PointCloudColorHandlerGenericField< sensor_msgs::PointCloud2 >Generic field handler class for colors. Uses an user given field to extract 1D data and display the color at each point using a min-max lookup table
pcl::visualization::PointCloudColorHandlerHSVField< PointT >HSV handler class for colors. Uses the data present in the "h", "s", "v" fields as the color at each point
pcl::visualization::PointCloudColorHandlerHSVField< sensor_msgs::PointCloud2 >HSV handler class for colors. Uses the data present in the "h", "s", "v" fields as the color at each point
pcl::visualization::PointCloudColorHandlerRandom< PointT >Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen)
pcl::visualization::PointCloudColorHandlerRandom< sensor_msgs::PointCloud2 >Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen)
pcl::visualization::PointCloudColorHandlerRGBField< PointT >RGB handler class for colors. Uses the data present in the "rgb" or "rgba" fields as the color at each point
pcl::visualization::PointCloudColorHandlerRGBField< sensor_msgs::PointCloud2 >RGB handler class for colors. Uses the data present in the "rgb" or "rgba" fields as the color at each point
pcl::octree::PointCloudCompression< PointT, LeafT, BranchT, OctreeT >Octree pointcloud compression class
pcl::visualization::PointCloudGeometryHandler< PointT >Base handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandler< sensor_msgs::PointCloud2 >Base handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandlerCustom< PointT >Custom handler class for PointCloud geometry. Given an input dataset and three user defined fields, all data present in them is extracted and displayed on screen as XYZ data
pcl::visualization::PointCloudGeometryHandlerCustom< sensor_msgs::PointCloud2 >Custom handler class for PointCloud geometry. Given an input dataset and three user defined fields, all data present in them is extracted and displayed on screen as XYZ data
pcl::visualization::PointCloudGeometryHandlerSurfaceNormal< PointT >Surface normal handler class for PointCloud geometry. Given an input dataset, all data present in fields "normal_x", "normal_y", and "normal_z" is extracted and dislayed on screen as XYZ data
pcl::visualization::PointCloudGeometryHandlerSurfaceNormal< sensor_msgs::PointCloud2 >Surface normal handler class for PointCloud geometry. Given an input dataset, all data present in fields "normal_x", "normal_y", and "normal_z" is extracted and dislayed on screen as XYZ data
pcl::visualization::PointCloudGeometryHandlerXYZ< PointT >XYZ handler class for PointCloud geometry. Given an input dataset, all XYZ data present in fields "x", "y", and "z" is extracted and displayed on screen
pcl::visualization::PointCloudGeometryHandlerXYZ< sensor_msgs::PointCloud2 >XYZ handler class for PointCloud geometry. Given an input dataset, all XYZ data present in fields "x", "y", and "z" is extracted and displayed on screen
pcl::octree::PointCoding< PointT >PointCoding class
pcl::tracking::PointCoherence< PointInT >PointCoherence is a base class to compute coherence between the two points
pcl::PointCorrespondence3DRepresentation of a (possible) correspondence between two 3D points in two different coordinate frames (e.g. from feature matching)
pcl::PointCorrespondence6DRepresentation of a (possible) correspondence between two points (e.g. from feature matching), that encode complete 6DOF transoformations
pcl::PointDataAtOffset< PointT >A datatype that enables type-correct comparisons
pcl::poisson::Octree< Degree >::PointIndexValueAndNormalFunction
pcl::poisson::Octree< Degree >::PointIndexValueFunction
pcl::PointNormal
pcl::visualization::PointPickingCallback
pcl::visualization::PointPickingEvent
pcl::PointRepresentation< PointT >PointRepresentation provides a set of methods for converting a point structs/object into an n-dimensional vector
pcl::PointSurfel
pcl::PointWithRange
pcl::PointWithScale
pcl::PointWithViewpointA point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen
pcl::PointXYA 2D point structure representing Euclidean xy coordinates
pcl::PointXYZA point structure representing Euclidean xyz coordinates. (SSE friendly)
PointXYZFPFH33
pcl::PointXYZHSV
pcl::PointXYZI
pcl::PointXYZINormal
pcl::PointXYZL
pcl::PointXYZRGBA point structure representing Euclidean xyz coordinates, and the RGB color
pcl::PointXYZRGBA
pcl::PointXYZRGBL
pcl::PointXYZRGBNormal
pcl::Poisson< PointNT >The Poisson surface reconstruction algorithm
pcl::poisson::Polynomial< Degree >
pcl::PolynomialCalculationsT< real >This provides some functionality for polynomials, like finding roots or approximating bivariate polynomials
pcl::PosesFromMatches::PoseEstimateA result of the pose estimation process
pcl::PosesFromMatchesCalculate 3D transformation based on point correspondencdes
pcl::PPFRegistration< PointSource, PointTarget >::PoseWithVotesStructure for storing a pose (represented as an Eigen::Affine3f) and an integer for counting votes
pcl::PPFEstimation< PointInT, PointNT, PointOutT >Class that calculates the "surflet" features for each pair in the given pointcloud. Please refer to the following publication for more details: B. Drost, M. Ulrich, N. Navab, S. Ilic Model Globally, Match Locally: Efficient and Robust 3D Object Recognition 2010 IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 13-18 June 2010, San Francisco, CA
pcl::PPFEstimation< PointInT, PointNT, Eigen::MatrixXf >Class that calculates the "surflet" features for each pair in the given pointcloud. Please refer to the following publication for more details: B. Drost, M. Ulrich, N. Navab, S. Ilic Model Globally, Match Locally: Efficient and Robust 3D Object Recognition 2010 IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 13-18 June 2010, San Francisco, CA
pcl::PPFHashMapSearch
pcl::PPFRegistration< PointSource, PointTarget >Class that registers two point clouds based on their sets of PPFSignatures. Please refer to the following publication for more details: B. Drost, M. Ulrich, N. Navab, S. Ilic Model Globally, Match Locally: Efficient and Robust 3D Object Recognition 2010 IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 13-18 June 2010, San Francisco, CA
pcl::PPFRGBEstimation< PointInT, PointNT, PointOutT >
pcl::PPFRGBRegionEstimation< PointInT, PointNT, PointOutT >
pcl::PPFRGBSignatureA point structure for storing the Point Pair Color Feature (PPFRGB) values
pcl::PPFSignatureA point structure for storing the Point Pair Feature (PPF) values
pcl::poisson::PPolynomial< Degree >
pcl::PrincipalCurvaturesA point structure representing the principal curvatures and their magnitudes
pcl::PrincipalCurvaturesEstimation< PointInT, PointNT, PointOutT >PrincipalCurvaturesEstimation estimates the directions (eigenvectors) and magnitudes (eigenvalues) of principal surface curvatures for a given point cloud dataset containing points and normals
pcl::PrincipalCurvaturesEstimation< PointInT, PointNT, Eigen::MatrixXf >PrincipalCurvaturesEstimation estimates the directions (eigenvectors) and magnitudes (eigenvalues) of principal surface curvatures for a given point cloud dataset containing points and normals
pcl::PrincipalRadiiRSDA point structure representing the minimum and maximum surface radii (in meters) computed using RSD
pcl::octree::OctreePointCloudSearch< PointT, LeafT, BranchT >::prioBranchQueueEntryPriority queue entry for branch nodes
pcl::octree::OctreePointCloudSearch< PointT, LeafT, BranchT >::prioPointQueueEntryPriority queue entry for point candidates
prioPointQueueEntry
pcl::ProgressiveSampleConsensus< PointT >RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Matching with PROSAC – Progressive Sample Consensus", Chum, O. and Matas, J.G., CVPR, I: 220-226 2005
pcl::ProjectInliers< PointT >ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud
pcl::ProjectInliers< sensor_msgs::PointCloud2 >ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud
pcl::io::ply::ply_parser::property
pcl::PyramidFeatureHistogram< PointFeature >Class that compares two sets of features by using a multiscale representation of the features inside a pyramid. Each level of the pyramid offers information about the similarity of the two feature sets
pcl::PyramidFeatureHistogram< PointFeature >::PyramidFeatureHistogramLevelStructure for representing a single pyramid histogram level
pcl::RadiusOutlierRemoval< PointT >RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have
pcl::RadiusOutlierRemoval< sensor_msgs::PointCloud2 >RadiusOutlierRemoval is a simple filter that removes outliers if the number of neighbors in a certain search radius is smaller than a given K
pcl::RandomizedMEstimatorSampleConsensus< PointT >RandomizedMEstimatorSampleConsensus represents an implementation of the RMSAC (Randomized M-estimator SAmple Consensus) algorithm, which basically adds a Td,d test (see RandomizedRandomSampleConsensus) to an MSAC estimator (see MEstimatorSampleConsensus)
pcl::RandomizedRandomSampleConsensus< PointT >RandomizedRandomSampleConsensus represents an implementation of the RRANSAC (Randomized RAndom SAmple Consensus), as described in "Randomized RANSAC with Td,d test", O. Chum and J. Matas, Proc. British Machine Vision Conf. (BMVC '02), vol. 2, BMVA, pp. 448-457, 2002
pcl::RandomSample< PointT >RandomSample applies a random sampling with uniform probability. Based off Algorithm A from the paper "Faster Methods for Random Sampling" by Jeffrey Scott Vitter. The algorithm runs in O(N) and results in sorted indices http://www.ittc.ku.edu/~jsv/Papers/Vit84.sampling.pdf
pcl::RandomSample< sensor_msgs::PointCloud2 >RandomSample applies a random sampling with uniform probability
pcl::RandomSampleConsensus< PointT >RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography", Martin A. Fischler and Robert C. Bolles, Comm. Of the ACM 24: 381–395, June 1981
pcl::RangeImageRangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where a 3D scene was captured from a specific view point
pcl::RangeImageBorderExtractorExtract obstacle borders from range images, meaning positions where there is a transition from foreground to background
pcl::RangeImagePlanarRangeImagePlanar is derived from the original range image and differs from it because it's not a spherical projection, but using a projection plane (as normal cameras do), therefore being better applicable for range sensors that already provide a range image by themselves (stereo cameras, ToF-cameras), so that a conversion to point cloud and then to a spherical range image becomes unnecessary
pcl::visualization::RangeImageVisualizerRange image visualizer class
Recorder
pcl::ReferenceFrame
pcl::poisson::Octree< Degree >::RefineFunction
pcl::Region3D< PointT >Region3D represents summary statistics of a 3D collection of points
pcl::Registration< PointSource, PointTarget >Registration represents the base registration class. All 3D registration methods should inherit from this class
pcl::RegistrationVisualizer< PointSource, PointTarget >RegistrationVisualizer represents the base class for rendering the intermediate positions ocupied by the source point cloud during it's registration to the target point cloud. A registration algorithm is considered as input and it's covergence is rendered
RegistrationWrapper< PointSource, PointTarget >
pcl::apps::RenderViewsTesselatedSphereClass to render synthetic views of a 3D mesh using a tesselated sphere NOTE: This class should replace renderViewTesselatedSphere from pcl::visualization. Some extensions are planned in the near future to this class like removal of duplicated views for symmetrical objects, generation of RGB synthetic clouds when RGB available on mesh, etc
pcl::visualization::RenWinInteract
pcl::poisson::Octree< Degree >::RestrictedLaplacianMatrixFunction
TemplateAlignment::Result
pcl::TexMaterial::RGB
pcl::RGBA structure representing RGB color information
pcl::RGBPlaneCoefficientComparator< PointT, PointNT >RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. Also takes into account RGB, so we can segmented different colored co-planar regions. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data
pcl::tracking::RGBValue
pcl::RIFTEstimation< PointInT, GradientT, PointOutT >RIFTEstimation estimates the Rotation Invariant Feature Transform descriptors for a given point cloud dataset containing points and intensity. For more information about the RIFT descriptor, see:
pcl::RIFTEstimation< PointInT, GradientT, Eigen::MatrixXf >RIFTEstimation estimates the Rotation Invariant Feature Transform descriptors for a given point cloud dataset containing points and intensity. For more information about the RIFT descriptor, see:
pcl::poisson::RootInfo
pcl::RSDEstimation< PointInT, PointNT, PointOutT >RSDEstimation estimates the Radius-based Surface Descriptor (minimal and maximal radius of the local surface's curves) for a given point cloud dataset containing points and normals
pcl::SACSegmentation< PointT >SACSegmentation represents the Nodelet segmentation class for Sample Consensus methods and models, in the sense that it just creates a Nodelet wrapper for generic-purpose SAC-based segmentation
pcl::SACSegmentationFromNormals< PointT, PointNT >SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and models that require the use of surface normals for estimation
pcl::SampleConsensus< T >SampleConsensus represents the base class. All sample consensus methods must inherit from this class
pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >SampleConsensusInitialAlignment is an implementation of the initial alignment algorithm described in section IV of "Fast Point Feature Histograms (FPFH) for 3D Registration," Rusu et al
pcl::SampleConsensusModel< PointT >SampleConsensusModel represents the base model class. All sample consensus models must inherit from this class
pcl::SampleConsensusModelCircle2D< PointT >SampleConsensusModelCircle2D defines a model for 2D circle segmentation on the X-Y plane
pcl::SampleConsensusModelCone< PointT, PointNT >SampleConsensusModelCone defines a model for 3D cone segmentation. The model coefficients are defined as:
pcl::SampleConsensusModelCylinder< PointT, PointNT >SampleConsensusModelCylinder defines a model for 3D cylinder segmentation. The model coefficients are defined as:
pcl::SampleConsensusModelFromNormals< PointT, PointNT >SampleConsensusModelFromNormals represents the base model class for models that require the use of surface normals for estimation
pcl::SampleConsensusModelLine< PointT >SampleConsensusModelLine defines a model for 3D line segmentation. The model coefficients are defined as:
pcl::SampleConsensusModelNormalParallelPlane< PointT, PointNT >SampleConsensusModelNormalParallelPlane defines a model for 3D plane segmentation using additional surface normal constraints. Basically this means that checking for inliers will not only involve a "distance to model" criterion, but also an additional "maximum angular deviation" between the plane's normal and the inlier points normals. In addition, the plane normal must lie parallel to an user-specified axis
pcl::SampleConsensusModelNormalPlane< PointT, PointNT >SampleConsensusModelNormalPlane defines a model for 3D plane segmentation using additional surface normal constraints. Basically this means that checking for inliers will not only involve a "distance to model" criterion, but also an additional "maximum angular deviation" between the plane's normal and the inlier points normals
pcl::SampleConsensusModelNormalSphere< PointT, PointNT >SampleConsensusModelNormalSphere defines a model for 3D sphere segmentation using additional surface normal constraints. Basically this means that checking for inliers will not only involve a "distance to model" criterion, but also an additional "maximum angular deviation" between the sphere's normal and the inlier points normals
pcl::SampleConsensusModelParallelLine< PointT >SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular constraints. The model coefficients are defined as:
pcl::SampleConsensusModelParallelPlane< PointT >SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional angular constraints. The plane must be parallel to a user-specified axis (setAxis) within an user-specified angle threshold (setEpsAngle)
pcl::SampleConsensusModelPerpendicularPlane< PointT >SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional angular constraints. The plane must be perpendicular to an user-specified axis (setAxis), up to an user-specified angle threshold (setEpsAngle). The model coefficients are defined as:
pcl::SampleConsensusModelPlane< PointT >SampleConsensusModelPlane defines a model for 3D plane segmentation. The model coefficients are defined as:
pcl::SampleConsensusModelRegistration< PointT >SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection
pcl::SampleConsensusModelSphere< PointT >SampleConsensusModelSphere defines a model for 3D sphere segmentation. The model coefficients are defined as:
pcl::SampleConsensusModelStick< PointT >SampleConsensusModelStick defines a model for 3D stick segmentation. A stick is a line with an user given minimum/maximum width. The model coefficients are defined as:
pcl::io::ply::ply_parser::scalar_property< ScalarType >
pcl::io::ply::ply_parser::scalar_property_callback_type< ScalarType >
pcl::io::ply::ply_parser::scalar_property_definition_callback_type< ScalarType >
pcl::io::ply::ply_parser::scalar_property_definition_callbacks_type
ScanParameters
pcl::ScopeTimeClass to measure the time spent in a scope
pcl::search::Search< PointT >Generic search class. All search wrappers must inherit from this
pcl::SegmentDifferences< PointT >SegmentDifferences obtains the difference between two spatially aligned point clouds and returns the difference between them for a maximum given distance threshold
pcl::io::ply::ply_parser::list_property_definition_callbacks_type::sequence_product< Sequence1, Sequence2 >
pcl::SetIfFieldExists< PointOutT, InT >A helper functor that can set a specific value in a field if the field exists
pcl::RangeImageBorderExtractor::ShadowBorderIndicesStores the indices of the shadow border corresponding to obstacle borders
pcl::ShapeContextA point structure representing a Shape Context
pcl::ShapeContext3DEstimation< PointInT, PointNT, PointOutT >ShapeContext3DEstimation implements the 3D shape context descriptor as described in:
pcl::ShapeContext3DEstimation< PointInT, PointNT, Eigen::MatrixXf >ShapeContext3DEstimation implements the 3D shape context descriptor as described in:
pcl::SHOTA point structure representing the generic Signature of Histograms of OrienTations (SHOT)
pcl::SHOT1344A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+color
pcl::SHOT352A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape only
pcl::SHOTColorEstimation< PointInT, PointNT, PointOutT, PointRFT >SHOTColorEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points, normals and colors
pcl::SHOTColorEstimation< PointInT, PointNT, Eigen::MatrixXf, PointRFT >
pcl::SHOTColorEstimationOMP< PointInT, PointNT, PointOutT, PointRFT >
pcl::SHOTEstimation< PointInT, PointNT, PointOutT, PointRFT >SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
pcl::SHOTEstimation< PointInT, PointNT, Eigen::MatrixXf, PointRFT >SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
pcl::SHOTEstimationBase< PointInT, PointNT, PointOutT, PointRFT >SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
pcl::SHOTEstimationOMP< PointInT, PointNT, PointOutT, PointRFT >SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals, in parallel, using the OpenMP standard
pcl::SHOTLocalReferenceFrameEstimation< PointInT, PointOutT >SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor
pcl::SHOTLocalReferenceFrameEstimationOMP< PointInT, PointOutT >SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor
pcl::SIFTKeypoint< PointInT, PointOutT >SIFTKeypoint detects the Scale Invariant Feature Transform keypoints for a given point cloud dataset containing points and intensity. This implementation adapts the original algorithm from images to point clouds
pcl::SIFTKeypointFieldSelector< PointT >
pcl::SIFTKeypointFieldSelector< PointNormal >
pcl::SIFTKeypointFieldSelector< PointXYZ >
pcl::SIFTKeypointFieldSelector< PointXYZRGB >
pcl::SIFTKeypointFieldSelector< PointXYZRGBA >
SimpleONIViewer< PointType >
SimpleOpenNIProcessor
SimpleOpenNIViewer< PointType >
pcl::surface::SimplificationRemoveUnusedVertices
pcl::SmoothedSurfacesKeypoint< PointT, PointNT >Based on the paper: Xinju Li and Igor Guskov Multi-scale features for approximate alignment of point-based surfaces Proceedings of the third Eurographics symposium on Geometry processing July 2005, Vienna, Austria
pcl::SolverDidntConvergeExceptionAn exception that is thrown when the non linear solver didn't converge
pcl::registration::sortCorrespondencesByDistance
pcl::registration::sortCorrespondencesByMatchIndex
pcl::registration::sortCorrespondencesByMatchIndexAndDistance
pcl::registration::sortCorrespondencesByQueryIndex
pcl::registration::sortCorrespondencesByQueryIndexAndDistance
pcl::poisson::SortedTreeNodes
pcl::poisson::SparseMatrix< T >
pcl::poisson::SparseNMatrix< T, Dim >
pcl::poisson::SparseSymmetricMatrix< T >
pcl::SpinImageEstimation< PointInT, PointNT, PointOutT >Estimates spin-image descriptors in the given input points
pcl::SpinImageEstimation< PointInT, PointNT, Eigen::MatrixXf >Estimates spin-image descriptors in the given input points
pcl::poisson::Square
pcl::poisson::StartingPolynomial< Degree >
pcl::StaticRangeCoderStaticRangeCoder compression class
pcl::StatisticalMultiscaleInterestRegionExtraction< PointT >Class for extracting interest regions from unstructured point clouds, based on a multi scale statistical approach. Please refer to the following publications for more details: Ranjith Unnikrishnan and Martial Hebert Multi-Scale Interest Regions from Unorganized Point Clouds Workshop on Search in 3D (S3D), IEEE Conf. on Computer Vision and Pattern Recognition (CVPR) June, 2008
pcl::StatisticalOutlierRemoval< PointT >StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data
pcl::StatisticalOutlierRemoval< sensor_msgs::PointCloud2 >StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data. For more information check:
pcl::StopWatchSimple stopwatch
pcl::SurfaceReconstruction< PointInT >SurfaceReconstruction represents a base surface reconstruction class. All surface reconstruction methods take in a point cloud and generate a new surface from it, by either re-sampling the data or generating new data altogether. These methods are thus not preserving the topology of the original data
pcl::SurfelSmoothing< PointT, PointNT >
pcl::Synchronizer< T1, T2 >
pcl::io::TARHeaderA TAR file's header, as described on http://en.wikipedia.org/wiki/Tar_%28file_format%29
TemplateAlignment
pcl::TexMaterial
pcl::TextureMapping< PointInT >The texture mapping algorithm
pcl::TextureMesh
pcl::TfQuadraticXYZComparison< PointT >A comparison whether the (x,y,z) components of a given point satisfy (p'Ap + 2v'p + c [OP] 0). Here [OP] stands for the defined pcl::ComparisonOps, i.e. for GT, GE, LT, LE or EQ; p = (x,y,z) is a point of the point cloud; A is 3x3 matrix; v is the 3x1 vector; c is a scalar
pcl::console::TicToc
pcl::TimeTriggerTimer class that invokes registered callback methods periodically
pcl::tracking::Tracker< PointInT, StateT >Tracker represents the base tracker class
pcl::registration::TransformationEstimation< PointSource, PointTarget >TransformationEstimation represents the base class for methods for transformation estimation based on:
pcl::registration::TransformationEstimationLM< PointSource, PointTarget >
pcl::registration::TransformationEstimationPointToPlane< PointSource, PointTarget >
pcl::registration::TransformationEstimationPointToPlaneLLS< PointSource, PointTarget >TransformationEstimationPointToPlaneLLS implements a Linear Least Squares (LLS) approximation for minimizing the point-to-plane distance between two clouds of corresponding points with normals
pcl::registration::TransformationEstimationSVD< PointSource, PointTarget >
pcl::TransformationFromCorrespondencesCalculates a transformation based on corresponding 3D points
pcl::registration::TransformationValidation< PointSource, PointTarget >TransformationValidation represents the base class for methods that validate the correctness of a transformation found through TransformationEstimation
pcl::registration::TransformationValidationEuclidean< PointSource, PointTarget >TransformationValidationEuclidean computes an L2SQR norm between a source and target dataset
pcl::poisson::TreeNodeData
pcl::poisson::Triangle
pcl::poisson::TriangleIndex
pcl::poisson::Triangulation< Real >
pcl::poisson::TriangulationEdge
pcl::poisson::TriangulationTriangle
pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::TruncatedError
pcl::UnhandledPointTypeException
pcl::UniformSampling< PointInT >UniformSampling assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::UniqueShapeContext< PointInT, PointOutT, PointRFT >UniqueShapeContext implements the Unique Shape Descriptor described here:
pcl::UniqueShapeContext< PointInT, Eigen::MatrixXf, PointRFT >UniqueShapeContext implements the Unique Shape Descriptor described here:
pcl::UnorganizedPointCloudExceptionAn exception that is thrown when an organized point cloud is needed but not provided
pcl::texture_mapping::UvIndexStructure that links a uv coordinate to its 3D point and face
pcl::poisson::Vector< T >
pcl::VectorAverage< real, dimension >Calculates the weighted average and the covariance matrix
pcl::registration::ELCH< PointT >::Vertex
pcl::poisson::VertexData
pcl::VFHClassifierNNUtility class for nearest neighbor search based classification of VFH features
pcl::VFHEstimation< PointInT, PointNT, PointOutT >VFHEstimation estimates the Viewpoint Feature Histogram (VFH) descriptor for a given point cloud dataset containing points and normals. The default VFH implementation uses 45 binning subdivisions for each of the three extended FPFH values, plus another 45 binning subdivisions for the distances between each point and the centroid and 128 binning subdivisions for the viewpoint component, which results in a 308-byte array of float values. These are stored in a pcl::VFHSignature308 point type. A major difference between the PFH/FPFH descriptors and VFH, is that for a given point cloud dataset, only a single VFH descriptor will be estimated (vfhs->points.size() should be 1), while the resultant PFH/FPFH data will have the same number of entries as the number of points in the cloud
pcl::VFHSignature308A point structure representing the Viewpoint Feature Histogram (VFH)
pcl::VoxelGrid< PointT >VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::VoxelGrid< sensor_msgs::PointCloud2 >VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::VTKUtils
pcl::WarpPointRigid< PointSourceT, PointTargetT >
pcl::WarpPointRigid3D< PointSourceT, PointTargetT >
pcl::WarpPointRigid6D< PointSourceT, PointTargetT >
pcl::visualization::Window
pcl::xNdCopyEigenPointFunctor< PointT >Helper functor structure for copying data between an Eigen::VectorXf and a PointT
pcl::xNdCopyPointEigenFunctor< PointT >Helper functor structure for copying data between an Eigen::VectorXf and a PointT


pcl
Author(s): Open Perception
autogenerated on Mon Oct 6 2014 03:20:40