Point Cloud Library (PCL)
1.8.1dev

__gnu_cxx  
hash< long long >  
hash< const long long >  
hash< unsigned long long >  
hash< const unsigned long long >  
BFGSSpace  
boost  
detail  
is_random_access< eigen_vecS >  
is_random_access< eigen_listS >  
eigen_vecS  
container_gen< eigen_vecS, ValueType >  
parallel_edge_traits< eigen_vecS >  
eigen_listS  
container_gen< eigen_listS, ValueType >  
parallel_edge_traits< eigen_listS >  
Eigen  
PolynomialSolver< _Scalar, 2 >  
NumTraits< pcl::ndt2d::NormalDist< PointT > >  
flann  
L2_Simple  
Index  
NNIndex  
L2  
Matrix  
Loki  
TL  
TypeAt  
TypeAt< Typelist< Head, Tail >, 0 >  
TypeAt< Typelist< Head, Tail >, i >  
NullType  
Typelist  
Int2Type  
NcvCTprep  Compiletime assert namespace 
CT_ASSERT_FAILURE  
CT_ASSERT_FAILURE< true >  
assertTest  
NCVRuntimeTemplateBool  
KernelCaller  
KernelCaller< TList, 0, Func >  
openni  
openni_wrapper  
DepthImage  This class provides methods to fill a depth or disparity image 
OpenNIDevice  Class representing an astract device for OpenNI devices: Primesense PSDK, Microsoft Kinect, Asus Xtion Pro/Live 
ShiftConversion  
DeviceKinect  Concrete implementation of the interface OpenNIDevice for a MS Kinect device 
DeviceONI  Concrete implementation of the interface OpenNIDevice for a virtual device playing back an ONI file 
DevicePrimesense  Concrete implementation of the interface OpenNIDevice for a Primesense device 
DeviceXtionPro  Concrete implementation of the interface OpenNIDevice for a Asus Xtion Pro device 
OpenNIDriver  Driver class implemented as Singleton 
DeviceContext  
OpenNIException  General exception class 
Image  Image class containing just a reference to image meta data 
ImageBayerGRBG  This class provides methods to fill a RGB or Grayscale image buffer from underlying Bayer pattern image 
ImageRGB24  This class provides methods to fill a RGB or Grayscale image buffer from underlying RGB24 image 
ImageYUV422  Concrete implementation of the interface Image for a YUV 422 image used by Primesense devices 
IRImage  Class containing just a reference to IR meta data 
ShiftToDepthConverter  This class provides conversion of the openni 11bit shift data to depth; 
pcl  
common  
internal  
CloudGenerator  
CloudGenerator< pcl::PointXY, GeneratorT >  
IntensityFieldAccessor< pcl::PointNormal >  
IntensityFieldAccessor< pcl::PointXYZ >  
IntensityFieldAccessor< pcl::PointXYZRGB >  
IntensityFieldAccessor< pcl::PointXYZRGBA >  
IntensityFieldAccessor< pcl::PointXYZRGBNormal >  
IntensityFieldAccessor< pcl::PointXYZRGBL >  
IntensityFieldAccessor< pcl::PointXYZHSV >  
IntensityFieldAccessor< pcl::PointXYZL >  
IntensityFieldAccessor< pcl::PointXYZLNormal >  
IntensityFieldAccessor< pcl::InterestPoint >  
IntensityFieldAccessor< pcl::PointWithRange >  
IntensityFieldAccessor< pcl::PointWithScale >  
IntensityFieldAccessor< pcl::PointWithViewpoint >  
IntensityFieldAccessor< pcl::PointSurfel >  
IntensityFieldAccessor  
uniform_distribution  Uniform distribution dummy struct 
uniform_distribution< int >  Uniform distribution int specialized 
uniform_distribution< float >  Uniform distribution float specialized 
normal_distribution  Normal distribution 
UniformGenerator  UniformGenerator class generates a random number from range [min, max] at each run picked according to a uniform distribution i.e eaach number within [min, max] has almost the same probability of being drawn 
Parameters  
NormalGenerator  NormalGenerator class generates a random number from a normal distribution specified by (mean, sigma) 
Parameters  
ComparisonOps  
console  
TicToc  
cuda  
detail  
DjSets  
GraphEdge  
Graph  
SegmLinkVal  
SegmLink  
AddPoints  Simple kernel to add two points 
AddCovariances  Adds two matrices elementwise 
convert_point_to_float3  Simple kernel to convert a PointXYZRGB to float3 
ComputeCovarianceForPoint  Kernel to compute a ``covariance matrix'' for a single point 
OrganizedRadiusSearch  Kernel to compute a radius neighborhood given a organized point cloud (aka range image cloud) 
RGB  Default RGB structure, defined as a union over 4 chars 
PCLCUDABase  PCL base class 
CovarianceMatrix  Misnamed class holding a 3x3 matrix 
OpenNIRGB  Simple structure holding RGB data 
Host  Host helper class 
Device  Device helper class 
PointCloudAOS  PointCloudAOS represents an AOS (Array of Structs) PointCloud implementation for CUDA processing 
PointCloudSOA  PointCloudSOA represents a SOA (Struct of Arrays) PointCloud implementation for CUDA processing 
PointIterator  
PointIterator< Device, T >  
PointIterator< Host, T >  
StoragePointer  
StoragePointer< Device, T >  
StoragePointer< Host, T >  
StorageAllocator  
StorageAllocator< Device, T >  
StorageAllocator< Host, T >  
PointXYZRGB  Default point xyzrgb structure 
ScopeTimeCPU  Class to measure the time spent in a scope 
ScopeTimeGPU  Class to measure the time spent in a scope 
NormalEstimationKernel  
FastNormalEstimationKernel  
NormalDeviationKernel  
downsampleIndices  
DebayerBilinear  
DebayeringDownsampling  
YUV2RGBKernel  
YUV2RGB  
Debayering  
ComputeXYZ  Compute the XYZ values for a point based on disparity information 
ComputeXYZRGB  Compute the XYZ and RGB values for a point based on disparity information 
DisparityToCloud  Disparity to PointCloudAOS generator 
DisparityBoundSmoothing  
DisparityClampedSmoothing  
DisparityHelperMap  
isNotZero  
isInlier  Check if a certain tuple is a point inlier 
isNotInlier  
SetColor  
ChangeColor  
MultiRandomSampleConsensus  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 
RandomSampleConsensus  RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography", Martin A 
SampleConsensus  
DeleteIndices  Check if a certain tuple is a point inlier 
isNaNPoint  
SampleConsensusModel  SampleConsensusModel represents the base model class 
CountPlanarInlier  Check if a certain tuple is a point inlier 
NewCheckPlanarInlier  Check if a certain tuple is a point inlier 
CheckPlanarInlier  Check if a certain tuple is a point inlier 
CheckPlanarInlierIndices  Check if a certain tuple is a point inlier 
CheckPlanarInlierKinectNormalIndices  Check if a certain tuple is a point inlier 
CheckPlanarInlierKinectIndices  Check if a certain tuple is a point inlier 
CheckPlanarInlierNormalIndices  Check if a certain tuple is a point inlier 
SampleConsensusModel1PointPlane  SampleConsensusModel1PointPlane defines a model for 3D plane segmentation 
Create1PointPlaneHypothesis  Check if a certain tuple is a point inlier 
Create1PointPlaneSampleHypothesis  Check if a certain tuple is a point inlier 
parallel_random_generator  
SampleConsensusModelPlane  SampleConsensusModelPlane defines a model for 3D plane segmentation 
CreatePlaneHypothesis  Check if a certain tuple is a point inlier 
deprecated  
T  
detail  
AccumulatorXYZ  
AccumulatorNormal  
AccumulatorCurvature  
AccumulatorRGBA  
AccumulatorIntensity  
AccumulatorLabel  
Accumulators  
IsCompatible  
AddPoint  
GetPoint  
CopyPointHelper  
CopyPointHelper< PointInT, PointOutT, typename boost::enable_if< boost::is_same< PointInT, PointOutT > >::type >  
CopyPointHelper< PointInT, PointOutT, typename boost::enable_if< boost::mpl::and_< boost::mpl::not_< boost::is_same< PointInT, PointOutT > >, boost::mpl::or_< boost::mpl::not_< pcl::traits::has_color< PointInT > >, boost::mpl::not_< pcl::traits::has_color< PointOutT > >, boost::mpl::and_< pcl::traits::has_field< PointInT, pcl::fields::rgb >, pcl::traits::has_field< PointOutT, pcl::fields::rgb > >, boost::mpl::and_< pcl::traits::has_field< PointInT, pcl::fields::rgba >, pcl::traits::has_field< PointOutT, pcl::fields::rgba > > > > >::type >  
CopyPointHelper< PointInT, PointOutT, typename boost::enable_if< boost::mpl::and_< boost::mpl::not_< boost::is_same< PointInT, PointOutT > >, boost::mpl::or_< boost::mpl::and_< pcl::traits::has_field< PointInT, pcl::fields::rgb >, pcl::traits::has_field< PointOutT, pcl::fields::rgba > >, boost::mpl::and_< pcl::traits::has_field< PointInT, pcl::fields::rgba >, pcl::traits::has_field< PointOutT, pcl::fields::rgb > > > > >::type >  
FieldAdder  
FieldMapper  
FieldMapping  
device  
kinfuLS  
Intr  Camera intrinsics structure 
Mat33  3x3 Matrix for device code 
numeric_limits  
numeric_limits< float >  
numeric_limits< short >  
Eigen33  
MiniMat  
Block  
Warp  
Emulation  
LightSource  Light source collection 
float8  
float12  
Eigen33  
MiniMat  
Histogram  
PPFSignature  
PPFRGBSignature  
PrincipalCurvatures  
VFHEstimationImpl  
numeric_limits  
numeric_limits< float >  
numeric_limits< short >  
Block  
Warp  
Emulation  
Intr  Camera intrinsics structure 
Mat33  3x3 Matrix for device code 
LightSource  Light source collection 
float8  
float12  
OctreeIteratorDevice  
OctreeIteratorDeviceNS  
OctreeGlobal  
OctreeGlobalWithBox  
OctreeImpl  
OctreeDataHost  
Morton  
CalcMorton  
CompareByLevelCode  
OctreePriorityIteratorDevice  
prob_histogram  
ConnectedComponents  
Dilatation  
CUDATree  Struct that holds a single RDF tree in GPU 
MultiTreeLiveProc  Processor using multiple trees 
ProbabilityProc  Implementation Class to process probability histograms on GPU 
LessThanByFacet  
InitalSimplex  
FacetStream  
PointStream  
NonCachedLoad  
bit_not  
plusWeighted  
numeric_limits< bool >  
numeric_limits< char >  
numeric_limits< signed char >  
numeric_limits< unsigned char >  
numeric_limits< unsigned short >  
numeric_limits< int >  
numeric_limits< unsigned int >  
numeric_limits< long >  
numeric_limits< unsigned long >  
numeric_limits< double >  
Static  
Static< true >  
distances  
experimental  
EuclideanClusterComparator  
face_detection  
TrainingExample  
FeatureType  
RFTreeNode  
FaceDetectorDataProvider  
FeatureHandlerDepthAverage  
PoseClassRegressionVarianceStatsEstimator  Statistics estimator for regression trees which optimizes information gain and pose parameters error 
features  
ISMVoteList  This class is used for storing, analyzing and manipulating votes obtained from ISM algorithm 
ISMModel  The assignment of this structure is to store the statistical/learned weights and other information of the trained Implict Shape Model algorithm 
fields  
filters  
Convolution  Convolution is a mathematical operation on two functions f and g, producing a third function that is typically viewed as a modified version of one of the original functions 
ConvolvingKernel  Class ConvolvingKernel base class for all convolving kernels 
GaussianKernel  Gaussian kernel implementation interface Use this as implementation reference 
GaussianKernelRGB  Gaussian kernel implementation interface with RGB channel handling Use this as implementation reference 
Convolution3D  Convolution3D handles the non organized case where width and height are unknown or if you are only interested in convolving based on local neighborhood information 
ConvolvingKernel< PointT, pcl::Normal >  
ConvolvingKernel< PointT, pcl::PointXY >  
Pyramid  Pyramid constructs a multiscale representation of an organised point cloud 
geometry  
MeshIO  Read / write the halfedge mesh from / to a file 
MeshBase  Base class for the halfedge mesh 
VertexAroundVertexCirculator  Circulates counterclockwise around a vertex and returns an index to the terminating vertex of the outgoing halfedge (the target) 
OutgoingHalfEdgeAroundVertexCirculator  Circulates counterclockwise around a vertex and returns an index to the outgoing halfedge (the target) 
IncomingHalfEdgeAroundVertexCirculator  Circulates counterclockwise around a vertex and returns an index to the incoming halfedge (the target) 
FaceAroundVertexCirculator  Circulates counterclockwise around a vertex and returns an index to the face of the outgoing halfedge (the target) 
VertexAroundFaceCirculator  Circulates clockwise around a face and returns an index to the terminating vertex of the inner halfedge (the target) 
InnerHalfEdgeAroundFaceCirculator  Circulates clockwise around a face and returns an index to the inner halfedge (the target) 
OuterHalfEdgeAroundFaceCirculator  Circulates clockwise around a face and returns an index to the outer halfedge (the target) 
FaceAroundFaceCirculator  Circulates clockwise around a face and returns an index to the face of the outer halfedge (the target) 
Vertex  A vertex is a node in the mesh 
HalfEdge  An edge is a connection between two vertices 
Face  A face is a closed loop of edges 
VertexIndex  Index used to access elements in the halfedge mesh 
HalfEdgeIndex  Index used to access elements in the halfedge mesh 
EdgeIndex  Index used to access elements in the halfedge mesh 
FaceIndex  Index used to access elements in the halfedge mesh 
NoData  No data is associated with the vertices / halfedges / edges / faces 
DefaultMeshTraits  The mesh traits are used to set up compile time settings for the mesh 
PolygonMeshTag  Tag describing the type of the mesh 
PolygonMesh  General halfedge mesh that can store any polygon with a minimum number of vertices of 3 
QuadMeshTag  Tag describing the type of the mesh 
QuadMesh  Halfedge mesh that can only store quads 
TriangleMeshTag  Tag describing the type of the mesh 
TriangleMesh  Halfedge mesh that can only store triangles 
gpu  
kinfuLS  
ColorVolume  ColorVolume class 
CyclicalBuffer  CyclicalBuffer implements a cyclical TSDF buffer 
KinfuTracker  KinfuTracker class encapsulates implementation of Microsoft Kinect Fusion algorithm 
MarchingCubes  MarchingCubes implements MarchingCubes functionality for TSDF volume on GPU 
PixelRGB  Input/output pixel format for KinfuTracker 
RayCaster  Class that performs raycasting for TSDF volume 
StandaloneMarchingCubes  The Standalone Marching Cubes Class provides encapsulated functionality for the Marching Cubes implementation originally by Anatoly Baksheev 
tsdf_buffer  Structure to handle buffer addresses 
TsdfVolume  TsdfVolume class 
Header  Structure storing voxel grid resolution, volume size (in mm) and element_size of data stored on host 
CaptureOpenNI  
people  
label_skeleton  
trees  
AttribLocation  
Node  
Histogram  
HistogramPair  
SplitPoint  
LabeledAttrib  
LabeledFeature  
RDFBodyPartsDetector  
FaceDetector  
Blob2  This structure contains all parameters to describe blobs and their parent/child relations 
Tree2  This structure contains all parameters to describe the segmented tree 
OrganizedPlaneDetector  
PeopleDetector  
PersonAttribs  
ProbabilityProcessor  
DeviceArray  DeviceArray class 
DeviceArray2D  DeviceArray2D class 
DeviceMemory  DeviceMemory class 
DeviceMemory2D  DeviceMemory2D class 
DevPtr  
PtrSz  
PtrStep  
PtrStepSz  
Feature  Feature represents the base feature class 
FeatureFromNormals  Feature represents the base feature class that takes normals as input also 
NormalEstimation  Class for normal estimation 
PFHEstimation  Class for PFH estimation 
PFHRGBEstimation  Class for PFHRGB estimation 
FPFHEstimation  Class for FPFH estimation 
PPFEstimation  ** 
PPFRGBEstimation  ** 
PPFRGBRegionEstimation  ** 
PrincipalCurvaturesEstimation  Class for PPFRGBRegion estimation 
VFHEstimation  ** 
SpinImageEstimation  Class for SpinImages estimation 
DataSource  
Normal2PointXYZ  
ColorVolume  ColorVolume class 
KinfuTracker  KinfuTracker class encapsulates implementation of Microsoft Kinect Fusion algorithm 
MarchingCubes  MarchingCubes implements MarchingCubes functionality for TSDF volume on GPU 
PixelRGB  Input/output pixel format for KinfuTracker 
RayCaster  Class that performs raycasting for TSDF volume 
TsdfVolume  TsdfVolume class 
CaptureOpenNI  
NeighborIndices  
Octree  Octree implementation on GPU 
AsyncCopy  
EuclideanClusterExtraction  EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, depending on pcl::gpu::octree 
EuclideanLabeledClusterExtraction  EuclideanLabeledClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, depending on pcl::gpu::octree 
SeededHueSegmentation  
PseudoConvexHull3D  
ParticleFilterGPUTracker  
TextureBinder  
Timer  
ScopeTimer  
io  
depth_sense  
DepthSenseDeviceManager  A helper class for enumerating and managing access to DepthSense devices 
DepthSenseGrabberImpl  
openni2  
OpenNI2Device  
OpenNI2DeviceInfo  
OpenNI2DeviceManager  
OpenNI2FrameListener  
OpenNI2TimerFilter  
OpenNI2VideoMode  
ply  
io_operators  
type_traits  
ply_parser  Class ply_parser parses a PLY file and generates appropriate atomic parsers for the body 
list_property_begin_callback_type  
list_property_definition_callback_type  
list_property_definition_callbacks_type  
list_property_element_callback_type  
list_property_end_callback_type  
scalar_property_callback_type  
scalar_property_definition_callback_type  
scalar_property_definition_callbacks_type  
real_sense  
RealSenseDeviceManager  
RealSenseDevice  
configurationProfile_t  
OctreePointCloudCompression  Octree pointcloud compression class 
OrganizedPointCloudCompression  
CompressionPointTraits  
CompressionPointTraits< PointXYZRGB >  
CompressionPointTraits< PointXYZRGBA >  
OrganizedConversion  
OrganizedConversion< PointT, false >  
OrganizedConversion< PointT, true >  
Buffer  An abstract base class for fixedsize data buffers 
SingleBuffer  A simple buffer that only stores data 
MedianBuffer  A buffer that computes running window median of the data inserted 
AverageBuffer  A buffer that computes running window average of the data inserted 
DeBayer  Various debayering methods 
Image  Image interface class providing an interface to fill a RGB or Grayscale image buffer 
DepthImage  This class provides methods to fill a depth or disparity image 
IRImage  Class containing just a reference to IR meta data 
FrameWrapper  Pure abstract interface to wrap native frame data types 
ImageRGB24  This class provides methods to fill a RGB or Grayscale image buffer from underlying RGB24 image 
ImageYUV422  Concrete implementation of the interface Image for a YUV 422 image used by Primesense devices 
IOException  General IO exception class 
CameraParameters  Basic camera parameters placeholder 
LZFImageReader  PCLLZF image format reader 
LZFDepth16ImageReader  PCLLZF 16bit depth image format reader 
LZFRGB24ImageReader  PCLLZF 24bit RGB image format reader 
LZFYUV422ImageReader  PCLLZF 8bit Bayer image format reader 
LZFBayer8ImageReader  PCLLZF 8bit Bayer image format reader 
LZFImageWriter  PCLLZF image format writer 
LZFDepth16ImageWriter  PCLLZF 16bit depth image format writer 
LZFRGB24ImageWriter  PCLLZF 24bit RGB image format writer 
LZFYUV422ImageWriter  PCLLZF 16bit YUV422 image format writer 
LZFBayer8ImageWriter  PCLLZF 8bit Bayer image format writer 
PointCloudImageExtractor  Base Image Extractor class for organized point clouds 
PointCloudImageExtractorWithScaling  Image Extractor extension which provides functionality to apply scaling to the values extracted from a field 
PointCloudImageExtractorFromNormalField  Image Extractor which uses the data present in the "normal" field 
PointCloudImageExtractorFromRGBField  Image Extractor which uses the data present in the "rgb" or "rgba" fields to produce a color image with rgb8 encoding 
PointCloudImageExtractorFromLabelField  Image Extractor which uses the data present in the "label" field to produce either monochrome or RGB image where different labels correspond to different colors 
PointCloudImageExtractorFromZField  Image Extractor which uses the data present in the "z" field to produce a depth map (as a monochrome image with mono16 encoding) 
PointCloudImageExtractorFromCurvatureField  Image Extractor which uses the data present in the "curvature" field to produce a curvature map (as a monochrome image with mono16 encoding) 
PointCloudImageExtractorFromIntensityField  Image Extractor which uses the data present in the "intensity" field to produce a monochrome intensity image (with mono16 encoding) 
TARHeader  A TAR file's header, as described on http://en.wikipedia.org/wiki/Tar_%28file_format%29 
ism  
ImplicitShapeModelEstimation  This class implements Implicit Shape Model algorithm described in "Hough Transforms and 3D SURF for robust three dimensional classication" by Jan Knopp1, Mukta Prasad, Geert Willems1, Radu Timofte, and Luc Van Gool 
LocationInfo  This structure stores the information about the keypoint 
TC  This structure is used for determining the end of the kmeans clustering process 
VisualWordStat  Structure for storing the visual word 
keypoints  
agast  
AbstractAgastDetector  Abstract detector class for AGAST corner point detectors 
CompareScoreIndex  Score index comparator 
ScoreIndex  Structure holding an index and the associated keypoint score 
AgastDetector7_12s  Detector class for AGAST corner point detector (7_12s) 
AgastDetector5_8  Detector class for AGAST corner point detector (5_8) 
OastDetector9_16  Detector class for AGAST corner point detector (OAST 9_16) 
brisk  
Layer  A layer in the BRISK detector pyramid 
CommonParams  
ScaleSpace  BRISK Scale Space helper 
internal  
AgastApplyNonMaxSuppresion  
AgastApplyNonMaxSuppresion< pcl::PointUV >  
AgastDetector  
AgastDetector< pcl::PointUV >  
kinfuLS  
ScreenshotManager  Screenshot Manager saves a screenshot with the corresponding camera pose from Kinfu 
WorldModel  WorldModel maintains a 3D point cloud that can be queried and updated via helper functions 
ndt2d  
ValueAndDerivatives  Class to store vector value and first and second derivatives (grad vector and hessian matrix), so they can be returned easily from functions 
NormalDist  A normal distribution estimation class 
NDTSingleGrid  Build a set of normal distributions modelling a 2D point cloud, and provide the value and derivatives of the model at any point via the test (...) function 
NDT2D  Build a Normal Distributions Transform of a 2D point cloud 
occlusion_reasoning  
ZBuffering  Class to reason about occlusions 
octree  
ColorCoding  ColorCoding class 
PointCoding  PointCoding class 
BufferedBranchNode  
Octree2BufBase  Octree double buffer class 
OctreeBase  Octree class 
OctreeContainerBase  Octree container class that can serve as a base to construct own leaf node container classes 
OctreeContainerEmpty  Octree container class that does not store any information 
OctreeContainerPointIndex  Octree container class that does store a single point index 
OctreeContainerPointIndices  Octree container class that does store a vector of point indices 
IteratorState  
OctreeIteratorBase  Abstract octree iterator class 
OctreeDepthFirstIterator  Octree iterator class 
OctreeBreadthFirstIterator  Octree iterator class 
OctreeLeafNodeIterator  Octree leaf node iterator class 
OctreeKey  Octree key class 
OctreeNodePool  Octree node pool 
OctreeNode  Abstract octree node class 
OctreeLeafNode  Abstract octree leaf class 
OctreeBranchNode  Abstract octree branch class 
OctreePointCloud  Octree pointcloud class 
OctreePointCloudAdjacency  Octree pointcloud voxel class which maintains adjacency information for its voxels 
OctreePointCloudAdjacencyContainer  Octree adjacency leaf container class stores a list of pointers to neighbors, number of points added, and a DataT value 
OctreePointCloudChangeDetector  Octree pointcloud change detector class 
OctreePointCloudDensityContainer  Octree pointcloud density leaf node class 
OctreePointCloudDensity  Octree pointcloud density class 
OctreePointCloudOccupancy  Octree pointcloud occupancy class 
OctreePointCloudPointVector  Octree pointcloud point vector class 
OctreePointCloudSinglePoint  Octree pointcloud single point class 
OctreePointCloudVoxelCentroidContainer  Octree pointcloud voxel centroid leaf node class 
OctreePointCloudVoxelCentroid  Octree pointcloud voxel centroid class 
OctreePointCloudSearch  Octree pointcloud search class 
prioBranchQueueEntry  Priority queue entry for branch nodes 
prioPointQueueEntry  Priority queue entry for point candidates 
outofcore  
OutofcoreAbstractMetadata  
OutofcoreAbstractNodeContainer  
OutofcoreParams  
OutofcoreOctreeBase  This code defines the octree used for point storage at Urban Robotics 
OutofcoreOctreeBaseNode  OutofcoreOctreeBaseNode Class internally representing nodes of an outofcore octree, with accessors to its data via the pcl::outofcore::OutofcoreOctreeDiskContainer class or pcl::outofcore::OutofcoreOctreeRamContainer class, whichever it is templated against 
OutofcoreOctreeDiskContainer  Class responsible for serialization and deserialization of out of core point data 
OutofcoreOctreeRamContainer  Storage container class which the outofcore octree base is templated against 
OutofcoreOctreeBaseMetadata  Encapsulated class to read JSON metadata into memory, and write the JSON metadata associated with the octree root node 
OutofcoreBreadthFirstIterator  
OutofcoreDepthFirstIterator  
OutofcoreIteratorBase  Abstract octree iterator class 
OutofcoreOctreeNodeMetadata  Encapsulated class to read JSON metadata into memory, and write the JSON metadata for each node 
people  
GroundBasedPeopleDetectionApp  GroundBasedPeopleDetectionApp performs people detection on RGBD data having as input the ground plane coefficients 
HeadBasedSubclustering  HeadBasedSubclustering represents a class for searching for people inside a HeightMap2D based on a 3D head detection algorithm 
HeightMap2D  HeightMap2D represents a class for creating a 2D height map from a point cloud and searching for its local maxima 
HOG  HOG represents a class for computing the HOG descriptor described in Dalal, N 
PersonClassifier  
PersonCluster  PersonCluster represents a class for representing information about a cluster containing a person 
poisson  
AllocatorState  
Allocator  This templated class assists in memory allocation and is well suited for instances when it is known that the sequence of memory allocations is performed in a stackbased manner, so that memory allocated last is released first 
BinaryNode  
BSplineData  
BSplineComponents  
BSplineElementCoefficients  
BSplineElements  
FunctionData  
Point3D  
Edge  
Triangle  
CoredPointIndex  
EdgeIndex  
CoredEdgeIndex  
TriangleIndex  
TriangulationEdge  
TriangulationTriangle  
Triangulation  
CoredVertexIndex  
CoredMeshData  
CoredMeshData2  
Vertex  
CoredVectorMeshData  
CoredVectorMeshData2  
CoredFileMeshData  
CoredFileMeshData2  
Square  
Cube  
MarchingSquares  
MarchingCubes  
MinimalAreaTriangulation  
RootInfo  
VertexData  
SortedTreeNodes  
CornerIndices  
CornerTableData  
EdgeIndices  
EdgeTableData  
TreeNodeData  
Octree  
UpSampleData  
OctNode  
ConstNeighborKey3  
ConstNeighborKey5  
ConstNeighbors3  
ConstNeighbors5  
NeighborKey3  
NeighborKey5  
Neighbors3  
Neighbors5  
Polynomial  
StartingPolynomial  
PPolynomial  
MatrixEntry  
SparseMatrix  
MapReduceVector  
SparseSymmetricMatrix  
Vector  
NVector  
recognition  
aux  
HoughSpace3D  HoughSpace3D is a 3D voting space 
BVH  This class is an implementation of bounding volume hierarchies 
BoundedObject  
Node  
HypothesisBase  
Hypothesis  
ModelLibrary  
Model  Stores some information about the model 
ObjRecRANSAC  This is a RANSACbased 3D object recognition method 
HypothesisCreator  
OrientedPointPair  
Output  This is an output item of the ObjRecRANSAC::recognize() method 
ORRGraph  
Node  
ORROctree  That's a very specialized and simple octree class 
Node  
Data  
ORROctreeZProjection  
Pixel  
Set  
RotationSpaceCell  
Entry  
RotationSpaceCellCreator  
RotationSpace  This is a class for a discrete representation of the rotation space based on the axisangle representation 
RotationSpaceCreator  
RigidTransformSpace  
SimpleOctree  
Node  
TrimmedICP  
VoxelStructure  This class is a box in R3 built of voxels ordered in a regular rectangular grid 
registration  
ConvergenceCriteria  ConvergenceCriteria represents an abstract base class for different convergence criteria used in registration loops 
CorrespondenceEstimationBase  Abstract CorrespondenceEstimationBase class 
CorrespondenceEstimation  CorrespondenceEstimation represents the base class for determining correspondences between target and query point sets/features 
CorrespondenceEstimationBackProjection  CorrespondenceEstimationBackprojection computes correspondences as points in the target cloud which have minimum 
CorrespondenceEstimationNormalShooting  CorrespondenceEstimationNormalShooting computes correspondences as points in the target cloud which have minimum distance to normals computed on the input cloud 
CorrespondenceEstimationOrganizedProjection  CorrespondenceEstimationOrganizedProjection computes correspondences by projecting the source point cloud onto the target point cloud using the camera intrinsic and extrinsic parameters 
CorrespondenceRejector  CorrespondenceRejector represents the base class for correspondence rejection methods 
DataContainerInterface  DataContainerInterface provides a generic interface for computing correspondence scores between correspondent points in the input and target clouds 
DataContainer  DataContainer is a container for the input and target point clouds and implements the interface to compute correspondence scores between correspondent points in the input and target clouds 
CorrespondenceRejectorDistance  CorrespondenceRejectorDistance implements a simple correspondence rejection method based on thresholding the distances between the correspondences 
CorrespondenceRejectorFeatures  CorrespondenceRejectorFeatures implements a correspondence rejection method based on a set of feature descriptors 
FeatureContainer  An inner class containing pointers to the source and target feature clouds and the parameters needed to perform the correspondence search 
FeatureContainerInterface  
CorrespondenceRejectorMedianDistance  CorrespondenceRejectorMedianDistance implements a simple correspondence rejection method based on thresholding based on the median distance between the correspondences 
CorrespondenceRejectorOneToOne  CorrespondenceRejectorOneToOne implements a correspondence rejection method based on eliminating duplicate match indices in the correspondences 
CorrespondenceRejectionOrganizedBoundary  Implements a simple correspondence rejection measure 
CorrespondenceRejectorPoly  CorrespondenceRejectorPoly implements a correspondence rejection method that exploits lowlevel and poseinvariant geometric constraints between two point sets by forming virtual polygons of a userspecifiable cardinality on each model using the input correspondences 
CorrespondenceRejectorSampleConsensus  CorrespondenceRejectorSampleConsensus implements a correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers) 
CorrespondenceRejectorSampleConsensus2D  CorrespondenceRejectorSampleConsensus2D implements a pixelbased correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers) 
CorrespondenceRejectorSurfaceNormal  CorrespondenceRejectorSurfaceNormal implements a simple correspondence rejection method based on the angle between the normals at correspondent points 
CorrespondenceRejectorTrimmed  CorrespondenceRejectorTrimmed implements a correspondence rejection for ICPlike registration algorithms that uses only the best 'k' correspondences where 'k' is some estimate of the overlap between the two point clouds being registered 
CorrespondenceRejectorVarTrimmed  CorrespondenceRejectoVarTrimmed implements a simple correspondence rejection method by considering as inliers a certain percentage of correspondences with the least distances 
sortCorrespondencesByQueryIndex  sortCorrespondencesByQueryIndex : a functor for sorting correspondences by query index 
sortCorrespondencesByMatchIndex  sortCorrespondencesByMatchIndex : a functor for sorting correspondences by match index 
sortCorrespondencesByDistance  sortCorrespondencesByDistance : a functor for sorting correspondences by distance 
sortCorrespondencesByQueryIndexAndDistance  sortCorrespondencesByQueryIndexAndDistance : a functor for sorting correspondences by query index and distance 
sortCorrespondencesByMatchIndexAndDistance  sortCorrespondencesByMatchIndexAndDistance : a functor for sorting correspondences by match index and distance 
DefaultConvergenceCriteria  DefaultConvergenceCriteria represents an instantiation of ConvergenceCriteria, and implements the following criteria for registration loop evaluation: 
NullMeasurement  NullMeasurement struct 
PoseMeasurement  PoseMeasurement struct 
ELCH  ELCH (Explicit Loop Closing Heuristic) class 
Vertex  
GraphHandler  GraphHandler class is a wrapper for a general SLAM graph The actual graph class must fulfil the following boost::graph concepts: 
GraphOptimizer  GraphOptimizer class; derive and specialize for each graph type 
FPCSInitialAlignment  FPCSInitialAlignment computes corresponding four point congruent sets as described in: "4points congruent sets for robust pairwise surface registration", Dror Aiger, Niloy Mitra, Daniel CohenOr 
KFPCSInitialAlignment  KFPCSInitialAlignment computes corresponding four point congruent sets based on keypoints as described in: "Markerless point cloud registration with keypointbased 4points congruent sets", Pascal Theiler, Jan Dirk Wegner, Konrad Schindler 
IncrementalRegistration  Incremental IterativeClosestPoint class 
LUM  Globally Consistent Scan Matching based on an algorithm by Lu and Milios 
EdgeProperties  
VertexProperties  
MatchingCandidate  Container for matching candidate consisting of 
by_score  Sorting of candidates based on fitness score value 
MetaRegistration  Meta Registration class 
TransformationEstimation  TransformationEstimation represents the base class for methods for transformation estimation based on: 
TransformationEstimation2D  TransformationEstimation2D implements a simple 2D rigid transformation estimation (x, y, theta) for a given pair of datasets 
TransformationEstimation3Point  TransformationEstimation3Points represents the class for transformation estimation based on: 
TransformationEstimationDQ  TransformationEstimationDQ implements dual quaternion based estimation of the transformation aligning the given correspondences 
TransformationEstimationDualQuaternion  TransformationEstimationDualQuaternion implements dual quaternion based estimation of the transformation aligning the given correspondences 
TransformationEstimationLM  TransformationEstimationLM implements Levenberg Marquardtbased estimation of the transformation aligning the given correspondences 
Functor  Base functor all the models that need non linear optimization must define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec) or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) dependening on the chosen _Scalar 
OptimizationFunctor  
OptimizationFunctorWithIndices  
TransformationEstimationPointToPlane  TransformationEstimationPointToPlane uses Levenberg Marquardt optimization to find the transformation that minimizes the pointtoplane distance between the given correspondences 
TransformationEstimationPointToPlaneLLS  TransformationEstimationPointToPlaneLLS implements a Linear Least Squares (LLS) approximation for minimizing the pointtoplane distance between two clouds of corresponding points with normals 
TransformationEstimationPointToPlaneLLSWeighted  TransformationEstimationPointToPlaneLLSWeighted implements a Linear Least Squares (LLS) approximation for minimizing the pointtoplane distance between two clouds of corresponding points with normals, with the possibility of assigning weights to the correspondences 
TransformationEstimationPointToPlaneWeighted  TransformationEstimationPointToPlaneWeighted uses Levenberg Marquardt optimization to find the transformation that minimizes the pointtoplane distance between the given correspondences 
Functor  Base functor all the models that need non linear optimization must define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec) or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) dependening on the chosen _Scalar 
OptimizationFunctor  
OptimizationFunctorWithIndices  
TransformationEstimationSVD  TransformationEstimationSVD implements SVDbased estimation of the transformation aligning the given correspondences 
TransformationEstimationSVDScale  TransformationEstimationSVD implements SVDbased estimation of the transformation aligning the given correspondences 
TransformationValidation  TransformationValidation represents the base class for methods that validate the correctness of a transformation found through TransformationEstimation 
TransformationValidationEuclidean  TransformationValidationEuclidean computes an L2SQR norm between a source and target dataset 
MyPointRepresentation  Internal point representation uses only 3D coordinates for L2 
NullEstimate  NullEstimate struct 
PoseEstimate  PoseEstimate struct 
WarpPointRigid  Base warp point class 
WarpPointRigid3D  WarpPointRigid3D enables 3D (1D rotation + 2D translation) transformations for points 
WarpPointRigid6D  WarpPointRigid3D enables 6D (3D rotation + 3D translation) transformations for points 
search  
BruteForce  Implementation of a simple brute force search algorithm 
FlannSearch  search::FlannSearch is a generic FLANN wrapper class for the new search interface 
FlannIndexCreator  Helper class that creates a FLANN index from a given FLANN matrix 
KdTreeIndexCreator  Creates a FLANN KdTreeSingleIndex from the given input data 
KdTreeMultiIndexCreator  Creates a FLANN KdTreeIndex of multiple randomized trees from the given input data, suitable for feature matching 
KMeansIndexCreator  Creates a FLANN KdTreeSingleIndex from the given input data 
KdTree  search::KdTree is a wrapper class which inherits the pcl::KdTree class for performing search functions using KdTree structure 
Octree  search::Octree is a wrapper class which implements nearest neighbor search operations based on the pcl::octree::Octree structure 
OrganizedNeighbor  OrganizedNeighbor is a class for optimized nearest neigbhor search in organized point clouds 
Entry  
Search  Generic search class 
segmentation  
detail  
RandomWalker  Multilabel graph segmentation using random walks 
grabcut  
BoykovKolmogorov  Boost implementation of Boykov and Kolmogorov's maxflow algorithm doesn't support negative flows which makes it inappropriate for this conext 
Color  Structure to save RGB colors into floats 
Gaussian  Gaussian structure 
GMM  
GaussianFitter  Helper class that fits a single Gaussian to color samples 
surface  
SimplificationRemoveUnusedVertices  
test  Test_macros.h provide helper macros for testing vectors, matrices etc 
internal  
texture_mapping  
Camera  Structure to store camera pose and focal length 
UvIndex  Structure that links a uv coordinate to its 3D point and face 
tracking  
ApproxNearestPairPointCloudCoherence  ApproxNearestPairPointCloudCoherence computes coherence between two pointclouds using the approximate nearest point pairs 
PointCoherence  PointCoherence is a base class to compute coherence between the two points 
PointCloudCoherence  PointCloudCoherence is a base class to compute coherence between the two PointClouds 
DistanceCoherence  DistanceCoherence computes coherence between two points from the distance between them 
HSVColorCoherence  HSVColorCoherence computes coherence between the two points from the color difference between them 
RGBValue  
_ParticleXYZRPY  
ParticleXYZRPY  
_ParticleXYZR  
ParticleXYZR  
_ParticleXYRPY  
ParticleXYRPY  
_ParticleXYRP  
ParticleXYRP  
_ParticleXYR  
ParticleXYR  
KLDAdaptiveParticleFilterTracker  KLDAdaptiveParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method 
KLDAdaptiveParticleFilterOMPTracker  KLDAdaptiveParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method 
NearestPairPointCloudCoherence  NearestPairPointCloudCoherence computes coherence between two pointclouds using the nearest point pairs 
NormalCoherence  NormalCoherence computes coherence between two points from the angle between their normals 
ParticleFilterTracker  ParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method 
ParticleFilterOMPTracker  ParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method in parallel, using the OpenMP standard 
PyramidalKLTTracker  Pyramidal Kanade Lucas Tomasi tracker 
Tracker  Tracker represents the base tracker class 
traits  
asEnum  
asEnum< int8_t >  
asEnum< uint8_t >  
asEnum< int16_t >  
asEnum< uint16_t >  
asEnum< int32_t >  
asEnum< uint32_t >  
asEnum< float >  
asEnum< double >  
asType  
asType< pcl::PCLPointField::INT8 >  
asType< pcl::PCLPointField::UINT8 >  
asType< pcl::PCLPointField::INT16 >  
asType< pcl::PCLPointField::UINT16 >  
asType< pcl::PCLPointField::INT32 >  
asType< pcl::PCLPointField::UINT32 >  
asType< pcl::PCLPointField::FLOAT32 >  
asType< pcl::PCLPointField::FLOAT64 >  
decomposeArray  
POD  
name  
offset  
datatype  
fieldList  
utils  
visualization  
context_items  
Point  
Line  
Circle  
Disk  
Rectangle  
FilledRectangle  
Points  
Polygon  
Text  
Markers  
PointCloudColorHandlerRGBHack  
AreaPickingEvent  /brief Class representing 3D area picking events 
CloudViewer  Simple point cloud visualization class 
CloudActor  
Camera  Camera class holds a set of camera parameters together with the window pos/size 
FloatImageUtils  Provide some gerneral functionalities regarding 2d float arrays, e.g., for visualization purposes 
RenWinInteract  
PCLHistogramVisualizer  PCL histogram visualizer main class 
ImageViewerInteractorStyle  An image viewer interactor style, tailored for ImageViewer 
ImageViewer  ImageViewer is a class for 2D image visualization 
ExitCallback  
ExitMainLoopTimerCallback  
PCLVisualizerInteractor  The PCLVisualizer interactor 
PCLVisualizerInteractorStyle  PCLVisualizerInteractorStyle defines an unique, custom VTK based interactory style for PCL Visualizer applications 
PCLHistogramVisualizerInteractorStyle  PCL histogram visualizer interactory style class 
KeyboardEvent  /brief Class representing key hit/release events 
MouseEvent  
Figure2D  Abstract class for storing figure information 
FPolyLine2D  Class for PolyLine 
FPoints2D  Class for storing Points 
FQuad2D  Class for storing Quads 
FPolygon2D  Class for Polygon 
FEllipticArc2D  Class for storing EllipticArc; every ellipse , circle are covered by this 
PCLPainter2D  PCL Painter2D main class 
PCLPlotter  PCL Plotter main class 
PCLVisualizer  PCL Visualizer main class 
PointCloudColorHandler  Base Handler class for PointCloud colors 
PointCloudColorHandlerRandom  Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen) 
PointCloudColorHandlerCustom  Handler for predefined user colors 
PointCloudColorHandlerRGBField  RGB handler class for colors 
PointCloudColorHandlerHSVField  HSV handler class for colors 
PointCloudColorHandlerGenericField  Generic field handler class for colors 
PointCloudColorHandlerRGBAField  RGBA handler class for colors 
PointCloudColorHandlerLabelField  Label field handler class for colors 
PointCloudColorHandler< pcl::PCLPointCloud2 >  Base Handler class for PointCloud colors 
PointCloudColorHandlerRandom< pcl::PCLPointCloud2 >  Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen) 
PointCloudColorHandlerCustom< pcl::PCLPointCloud2 >  Handler for predefined user colors 
PointCloudColorHandlerRGBField< pcl::PCLPointCloud2 >  RGB handler class for colors 
PointCloudColorHandlerHSVField< pcl::PCLPointCloud2 >  HSV handler class for colors 
PointCloudColorHandlerGenericField< pcl::PCLPointCloud2 >  Generic field handler class for colors 
PointCloudColorHandlerRGBAField< pcl::PCLPointCloud2 >  RGBA handler class for colors 
PointCloudColorHandlerLabelField< pcl::PCLPointCloud2 >  Label field handler class for colors 
PointCloudGeometryHandler  Base handler class for PointCloud geometry 
PointCloudGeometryHandlerXYZ  XYZ handler class for PointCloud geometry 
PointCloudGeometryHandlerSurfaceNormal  Surface normal handler class for PointCloud geometry 
PointCloudGeometryHandlerCustom  Custom handler class for PointCloud geometry 
PointCloudGeometryHandler< pcl::PCLPointCloud2 >  Base handler class for PointCloud geometry 
PointCloudGeometryHandlerXYZ< pcl::PCLPointCloud2 >  XYZ handler class for PointCloud geometry 
PointCloudGeometryHandlerSurfaceNormal< pcl::PCLPointCloud2 >  Surface normal handler class for PointCloud geometry 
PointCloudGeometryHandlerCustom< pcl::PCLPointCloud2 >  Custom handler class for PointCloud geometry 
PointPickingCallback  
PointPickingEvent  /brief Class representing 3D point picking events 
RangeImageVisualizer  Range image visualizer class 
PCLSimpleBufferVisualizer  PCL simple buffer visualizer main class 
PCLContextItem  Struct PCLContextItem represents our own custom version of vtkContextItem, used by the ImageViewer class 
PCLContextImageItem  Struct PCLContextImageItem a specification of vtkContextItem, used to add an image to the scene in the ImageViewer class 
PCLImageCanvasSource2D  PCLImageCanvasSource2D represents our own custom version of vtkImageCanvasSource2D, used by the ImageViewer class 
Window  
ExitCallback  
ExitMainLoopTimerCallback  
PointXYZIEdge  This typedef is used to represent a point cloud containing edge information 
Convolution  A 2D convolution class 
Edge  
kernel  
Keypoint  Keypoint represents the base class for key points 
Morphology  
CloudIterator  Iterator class for point clouds with or without given indices 
ConstCloudIterator  Iterator class for point clouds with or without given indices 
ConstIteratorIdx  
DefaultConstIterator  
BivariatePolynomialT  This represents a bivariate polynomial and provides some functionality for it 
NdCentroidFunctor  Helper functor structure for nD centroid estimation 
CentroidPoint  A generic class that computes the centroid of points fed to it 
GlasbeyLUT  Color lookup table consisting of 256 colors structured in a maximally discontinuous manner 
NdConcatenateFunctor  Helper functor structure for concatenate 
FeatureHistogram  Type for histograms for computing mean and variance of some floats 
GaussianKernel  Class GaussianKernel assembles all the method for computing, convolving, smoothing, gradients computing an image using a gaussian kernel 
PCA  Principal Component analysis (PCA) class 
PiecewiseLinearFunction  This provides functionalities to efficiently return values for piecewise linear function 
PolynomialCalculationsT  This provides some functionality for polynomials, like finding roots or approximating bivariate polynomials 
Parameters  Parameters used in this class 
PosesFromMatches  Calculate 3D transformation based on point correspondencdes 
Parameters  Parameters used in this class 
PoseEstimate  A result of the pose estimation process 
IsBetter  
PointCloud  PointCloud represents the base class in PCL for storing collections of 3D points 
Synchronizer  /brief This template class synchronizes two data streams of different types 
StopWatch  Simple stopwatch 
ScopeTime  Class to measure the time spent in a scope 
EventFrequency  A helper class to measure frequency of a certain event 
TimeTrigger  Timer class that invokes registered callback methods periodically 
TransformationFromCorrespondences  Calculates a transformation based on corresponding 3D points 
VectorAverage  Calculates the weighted average and the covariance matrix 
Correspondence  Correspondence represents a match between two entities (e.g., points, descriptors, etc) 
PointCorrespondence3D  Representation of a (possible) correspondence between two 3D points in two different coordinate frames (e.g 
PointCorrespondence6D  Representation of a (possible) correspondence between two points (e.g 
PCLException  A base class for all pcl exceptions which inherits from std::runtime_error 
InvalidConversionException  An exception that is thrown when a PCLPointCloud2 message cannot be converted into a PCL type 
IsNotDenseException  An exception that is thrown when a PointCloud is not dense but is attemped to be used as dense 
InvalidSACModelTypeException  An exception that is thrown when a sample consensus model doesn't have the correct number of samples defined in model_types.h 
IOException  An exception that is thrown during an IO error (typical read/write errors) 
InitFailedException  An exception thrown when init can not be performed should be used in all the PCLBase class inheritants 
UnorganizedPointCloudException  An exception that is thrown when an organized point cloud is needed but not provided 
KernelWidthTooSmallException  An exception that is thrown when the kernel size is too small 
UnhandledPointTypeException  
ComputeFailedException  
BadArgumentException  An exception that is thrown when the argments number or type is wrong/unhandled 
for_each_type_impl  
for_each_type_impl< false >  
intersect  
DefaultIterator  
IteratorIdx  
_PointXYZ  
PointXYZ  A point structure representing Euclidean xyz coordinates 
_RGB  
RGB  A structure representing RGB color information 
_Intensity  
Intensity  A point structure representing the grayscale intensity in singlechannel images 
_Intensity8u  
Intensity8u  A point structure representing the grayscale intensity in singlechannel images 
_Intensity32u  
Intensity32u  A point structure representing the grayscale intensity in singlechannel images 
_PointXYZI  A point structure representing Euclidean xyz coordinates, and the intensity value 
PointXYZI  
_PointXYZL  
PointXYZL  
Label  
_PointXYZRGBA  
PointXYZRGBA  A point structure representing Euclidean xyz coordinates, and the RGBA color 
_PointXYZRGB  
_PointXYZRGBL  
PointXYZRGB  A point structure representing Euclidean xyz coordinates, and the RGB color 
PointXYZRGBL  
_PointXYZHSV  
PointXYZHSV  
PointXY  A 2D point structure representing Euclidean xy coordinates 
PointUV  A 2D point structure representing pixel image coordinates 
InterestPoint  A point structure representing an interest point with Euclidean xyz coordinates, and an interest value 
_Normal  
Normal  A point structure representing normal coordinates and the surface curvature estimate 
_Axis  
Axis  A point structure representing an Axis using its normal coordinates 
_PointNormal  
PointNormal  A point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate 
_PointXYZRGBNormal  
PointXYZRGBNormal  A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate 
_PointXYZINormal  
PointXYZINormal  A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate 
_PointXYZLNormal  
PointXYZLNormal  A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates and the surface curvature estimate 
_PointWithRange  
PointWithRange  A point structure representing Euclidean xyz coordinates, padded with an extra range float 
_PointWithViewpoint  
PointWithViewpoint  A point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen 
MomentInvariants  A point structure representing the three moment invariants 
PrincipalRadiiRSD  A point structure representing the minimum and maximum surface radii (in meters) computed using RSD 
Boundary  A point structure representing a description of whether a point is lying on a surface boundary or not 
PrincipalCurvatures  A point structure representing the principal curvatures and their magnitudes 
PFHSignature125  A point structure representing the Point Feature Histogram (PFH) 
PFHRGBSignature250  A point structure representing the Point Feature Histogram with colors (PFHRGB) 
PPFSignature  A point structure for storing the Point Pair Feature (PPF) values 
CPPFSignature  A point structure for storing the Point Pair Feature (CPPF) values 
PPFRGBSignature  A point structure for storing the Point Pair Color Feature (PPFRGB) values 
NormalBasedSignature12  A point structure representing the Normal Based Signature for a feature matrix of 4by3 
ShapeContext1980  A point structure representing a Shape Context 
UniqueShapeContext1960  A point structure representing a Unique Shape Context 
SHOT352  A point structure representing the generic Signature of Histograms of OrienTations (SHOT)  shape only 
SHOT1344  A point structure representing the generic Signature of Histograms of OrienTations (SHOT)  shape+color 
_ReferenceFrame  A structure representing the Local Reference Frame of a point 
ReferenceFrame  
FPFHSignature33  A point structure representing the Fast Point Feature Histogram (FPFH) 
VFHSignature308  A point structure representing the Viewpoint Feature Histogram (VFH) 
GRSDSignature21  A point structure representing the Global Radiusbased Surface Descriptor (GRSD) 
BRISKSignature512  A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK) 
ESFSignature640  A point structure representing the Ensemble of Shape Functions (ESF) 
GASDSignature512  A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor 
GASDSignature984  A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor 
GASDSignature7992  A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor 
GFPFHSignature16  A point structure representing the GFPFH descriptor with 16 bins 
Narf36  A point structure representing the Narf descriptor 
BorderDescription  A structure to store if a point in a range image lies on a border between an obstacle and the background 
IntensityGradient  A point structure representing the intensity gradient of an XYZI point cloud 
Histogram  A point structure representing an ND histogram 
_PointWithScale  
PointWithScale  A point structure representing a 3D position and scale 
_PointSurfel  
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 
_PointDEM  
PointDEM  A point structure representing Digital Elevation Map 
ModelCoefficients  
PCLBase  PCL base class 
PCLBase< pcl::PCLPointCloud2 >  
PCLHeader  
PCLImage  
PCLPointCloud2  
PCLPointField  
NdCopyEigenPointFunctor  Helper functor structure for copying data between an Eigen type and a PointT 
NdCopyPointEigenFunctor  Helper functor structure for copying data between an Eigen type and a PointT 
PointRepresentation  PointRepresentation provides a set of methods for converting a point structs/object into an ndimensional vector 
DefaultPointRepresentation  DefaultPointRepresentation extends PointRepresentation to define default behavior for common point types 
DefaultFeatureRepresentation  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) 
DefaultPointRepresentation< PointXYZ >  
DefaultPointRepresentation< PointXYZI >  
DefaultPointRepresentation< PointNormal >  
DefaultPointRepresentation< PFHSignature125 >  
DefaultPointRepresentation< PFHRGBSignature250 >  
DefaultPointRepresentation< PPFSignature >  
DefaultPointRepresentation< FPFHSignature33 >  
DefaultPointRepresentation< VFHSignature308 >  
DefaultPointRepresentation< Narf36 >  
DefaultPointRepresentation< NormalBasedSignature12 >  
DefaultPointRepresentation< ShapeContext1980 >  
DefaultPointRepresentation< UniqueShapeContext1960 >  
DefaultPointRepresentation< SHOT352 >  
DefaultPointRepresentation< SHOT1344 >  
CustomPointRepresentation  CustomPointRepresentation extends PointRepresentation to allow for subpart selection on the point 
FieldMatches  
CopyIfFieldExists  A helper functor that can copy a specific value if the given field exists 
SetIfFieldExists  A helper functor that can set a specific value in a field if the field exists 
PointIndices  
PolygonMesh  
BearingAngleImage  Class BearingAngleImage is used as an interface to generate Bearing Angle(BA) image 
RangeImage  RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where a 3D scene was captured from a specific view point 
RangeImagePlanar  RangeImagePlanar is derived from the original range image and differs from it because it's not a spherical projection, but using a projection plane (as normal cameras do), therefore being better applicable for range sensors that already provide a range image by themselves (stereo cameras, ToFcameras), so that a conversion to point cloud and then to a spherical range image becomes unnecessary 
RangeImageSpherical  RangeImageSpherical is derived from the original range image and uses a slightly different spherical projection 
TexMaterial  
RGB  
TextureMesh  
Vertices  Describes a set of vertices in a polygon mesh, by basically storing an array of indices 
OrganizedNeighborSearch  OrganizedNeighborSearch class 
nearestNeighborCandidate  nearestNeighborCandidate entry for the nearest neighbor candidate queue 
radiusSearchLoopkupEntry  radiusSearchLoopkupEntry entry for radius search lookup vector 
ShapeContext3DEstimation  ShapeContext3DEstimation implements the 3D shape context descriptor as described in: 
BOARDLocalReferenceFrameEstimation  BOARDLocalReferenceFrameEstimation implements the BOrder Aware Repeatable Directions algorithm for local reference frame estimation as described here: 
BoundaryEstimation  BoundaryEstimation estimates whether a set of points is lying on surface boundaries using an angle criterion 
BRISK2DEstimation  Implementation of the BRISKdescriptor, based on the original code and paper reference by 
CPPFEstimation  Class that calculates the "surflet" features for each pair in the given pointcloud 
CRHEstimation  CRHEstimation estimates the Camera Roll Histogram (CRH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in: 
CVFHEstimation  CVFHEstimation estimates the Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in: 
DifferenceOfNormalsEstimation  A Difference of Normals (DoN) scale filter implementation for point cloud data 
ESFEstimation  ESFEstimation estimates the ensemble of shape functions descriptors for a given point cloud dataset containing points 
Feature  Feature represents the base feature class 
FeatureFromNormals  
FeatureFromLabels  
FeatureWithLocalReferenceFrames  FeatureWithLocalReferenceFrames provides a public interface for descriptor extractor classes which need a local reference frame at each input keypoint 
FLARELocalReferenceFrameEstimation  FLARELocalReferenceFrameEstimation implements the Fast LocAl Reference framE algorithm for local reference frame estimation as described here: 
FPFHEstimation  FPFHEstimation estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals 
FPFHEstimationOMP  FPFHEstimationOMP estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals, in parallel, using the OpenMP standard 
GASDEstimation  GASDEstimation estimates the Globally Aligned Spatial Distribution (GASD) descriptor for a given point cloud dataset given XYZ data 
GASDColorEstimation  GASDColorEstimation estimates the Globally Aligned Spatial Distribution (GASD) descriptor for a given point cloud dataset given XYZ and RGB data 
GFPFHEstimation  GFPFHEstimation estimates the Global Fast Point Feature Histogram (GFPFH) descriptor for a given point cloud dataset containing points and labels 
GRSDEstimation  GRSDEstimation estimates the Global Radiusbased Surface Descriptor (GRSD) for a given point cloud dataset containing points and normals 
IntegralImageTypeTraits  
IntegralImageTypeTraits< float >  
IntegralImageTypeTraits< char >  
IntegralImageTypeTraits< short >  
IntegralImageTypeTraits< unsigned short >  
IntegralImageTypeTraits< unsigned char >  
IntegralImageTypeTraits< int >  
IntegralImageTypeTraits< unsigned int >  
IntegralImage2D  Determines an integral image representation for a given organized data array 
IntegralImage2D< DataType, 1 >  Partial template specialization for integral images with just one channel 
IntegralImageNormalEstimation  Surface normal estimation on organized data using integral images 
IntensityGradientEstimation  IntensityGradientEstimation estimates the intensity gradient for a point cloud that contains position and intensity values 
IntensitySpinEstimation  IntensitySpinEstimation estimates the intensitydomain spin image descriptors for a given point cloud dataset containing points and intensity 
LinearLeastSquaresNormalEstimation  Surface normal estimation on dense data using a leastsquares estimation based on a firstorder Taylor approximation 
MomentInvariantsEstimation  MomentInvariantsEstimation estimates the 3 moment invariants (j1, j2, j3) at each 3D point 
MomentOfInertiaEstimation  Implements the method for extracting features based on moment of inertia 
MultiscaleFeaturePersistence  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 
Narf  NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data 
FeaturePointRepresentation  
NarfDescriptor  Computes NARF feature descriptors for points in a range image See B 
Parameters  
NormalEstimation  NormalEstimation estimates local surface properties (surface normals and curvatures)at each 3D point 
NormalEstimationOMP  NormalEstimationOMP estimates local surface properties at each 3D point, such as surface normals and curvatures, in parallel, using the OpenMP standard 
NormalBasedSignatureEstimation  Normalbased feature signature estimation class 
OrganizedEdgeBase  OrganizedEdgeBase, OrganizedEdgeFromRGB, OrganizedEdgeFromNormals, and OrganizedEdgeFromRGBNormals find 3D edges from an organized point cloud data 
Neighbor  
OrganizedEdgeFromRGB  
OrganizedEdgeFromNormals  
OrganizedEdgeFromRGBNormals  
OURCVFHEstimation  OURCVFHEstimation estimates the Oriented, Unique and Repetable Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given point cloud dataset given XYZ data and normals, as presented in: 
PFHEstimation  PFHEstimation estimates the Point Feature Histogram (PFH) descriptor for a given point cloud dataset containing points and normals 
PFHRGBEstimation  
PPFEstimation  Class that calculates the "surflet" features for each pair in the given pointcloud 
PPFRGBEstimation  
PPFRGBRegionEstimation  
PrincipalCurvaturesEstimation  PrincipalCurvaturesEstimation estimates the directions (eigenvectors) and magnitudes (eigenvalues) of principal surface curvatures for a given point cloud dataset containing points and normals 
RangeImageBorderExtractor  Extract obstacle borders from range images, meaning positions where there is a transition from foreground to background 
LocalSurface  Stores some information extracted from the neighborhood of a point 
Parameters  Parameters used in this class 
ShadowBorderIndices  Stores the indices of the shadow border corresponding to obstacle borders 
RIFTEstimation  RIFTEstimation estimates the Rotation Invariant Feature Transform descriptors for a given point cloud dataset containing points and intensity 
ROPSEstimation  This class implements the method for extracting RoPS features presented in the article "Rotational Projection Statistics for 3D Local Surface Description and Object Recognition" by Yulan Guo, Ferdous Sohel, Mohammed Bennamoun, Min Lu and Jianwei Wan 
RSDEstimation  RSDEstimation estimates the Radiusbased Surface Descriptor (minimal and maximal radius of the local surface's curves) for a given point cloud dataset containing points and normals 
SHOTEstimationBase  SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals 
SHOTEstimation  SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals 
SHOTColorEstimation  SHOTColorEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points, normals and colors 
SHOTLocalReferenceFrameEstimation  SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor 
SHOTLocalReferenceFrameEstimationOMP  SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor 
SHOTEstimationOMP  SHOTEstimationOMP 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 
SHOTColorEstimationOMP  SHOTColorEstimationOMP estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points, normals and colors, in parallel, using the OpenMP standard 
SpinImageEstimation  Estimates spinimage descriptors in the given input points 
StatisticalMultiscaleInterestRegionExtraction  Class for extracting interest regions from unstructured point clouds, based on a multi scale statistical approach 
UniqueShapeContext  UniqueShapeContext implements the Unique Shape Context Descriptor described here: 
VFHEstimation  VFHEstimation estimates the Viewpoint Feature Histogram (VFH) descriptor for a given point cloud dataset containing points and normals 
xNdCopyEigenPointFunctor  Helper functor structure for copying data between an Eigen::VectorXf and a PointT 
xNdCopyPointEigenFunctor  Helper functor structure for copying data between an Eigen::VectorXf and a PointT 
ApproximateVoxelGrid  ApproximateVoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data 
BilateralFilter  A bilateral filter implementation for point cloud data 
BoxClipper3D  Implementation of a box clipper in 3D. Actually it allows affine transformations, thus any parallelepiped in general pose. The affine transformation is used to transform the point before clipping it using the unit cube centered at origin and with an extend of 1 to +1 in each dimension 
Clipper3D  Base class for 3D clipper objects 
PointDataAtOffset  A datatype that enables typecorrect comparisons 
ComparisonBase  The (abstract) base class for the comparison object 
FieldComparison  The fieldbased specialization of the comparison object 
PackedRGBComparison  A packed rgb specialization of the comparison object 
PackedHSIComparison  A packed HSI specialization of the comparison object 
TfQuadraticXYZComparison  A comparison whether the (x,y,z) components of a given point satisfy (p'Ap + 2v'p + c [OP] 0) 
ConditionBase  Base condition class 
ConditionAnd  AND condition 
ConditionOr  OR condition 
ConditionalRemoval  ConditionalRemoval filters data that satisfies certain conditions 
CovarianceSampling  Point Cloud sampling based on the 6D covariances 
CropBox  CropBox is a filter that allows the user to filter all the data inside of a given box 
CropBox< pcl::PCLPointCloud2 >  CropBox is a filter that allows the user to filter all the data inside of a given box 
CropHull  Filter points that lie inside or outside a 3D closed surface or 2D closed polygon, as generated by the ConvexHull or ConcaveHull classes 
ExtractIndices  ExtractIndices extracts a set of indices from a point cloud 
ExtractIndices< pcl::PCLPointCloud2 >  ExtractIndices extracts a set of indices from a point cloud 
FastBilateralFilter  Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper: 
Array3D  
FastBilateralFilterOMP  Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper: 
Filter  Filter represents the base filter class 
Filter< pcl::PCLPointCloud2 >  Filter represents the base filter class 
FilterIndices  FilterIndices represents the base class for filters that are about binary point removal 
FilterIndices< pcl::PCLPointCloud2 >  FilterIndices represents the base class for filters that are about binary point removal 
FrustumCulling  FrustumCulling filters points inside a frustum given by pose and field of view of the camera 
GridMinimum  GridMinimum assembles a local 2D grid over a given PointCloud, and downsamples the data 
LocalMaximum  LocalMaximum downsamples the cloud, by eliminating points that are locally maximal 
MedianFilter  Implementation of the median filter 
ModelOutlierRemoval  ModelOutlierRemoval filters points in a cloud based on the distance between model and point 
NormalRefinement  Normal vector refinement class 
NormalSpaceSampling  NormalSpaceSampling samples the input point cloud in the space of normal directions computed at every point 
PassThrough  PassThrough passes points in a cloud based on constraints for one particular field of the point type 
PassThrough< pcl::PCLPointCloud2 >  PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints 
PlaneClipper3D  Implementation of a plane clipper in 3D 
ProjectInliers  ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud 
ProjectInliers< pcl::PCLPointCloud2 >  ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud 
RadiusOutlierRemoval  RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have 
RadiusOutlierRemoval< pcl::PCLPointCloud2 >  RadiusOutlierRemoval is a simple filter that removes outliers if the number of neighbors in a certain search radius is smaller than a given K 
RandomSample  RandomSample applies a random sampling with uniform probability 
RandomSample< pcl::PCLPointCloud2 >  RandomSample applies a random sampling with uniform probability 
SamplingSurfaceNormal  SamplingSurfaceNormal divides the input space into grids until each grid contains a maximum of N points, and samples points randomly within each grid 
ShadowPoints  ShadowPoints removes the ghost points appearing on edge discontinuties 
StatisticalOutlierRemoval  StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data 
StatisticalOutlierRemoval< pcl::PCLPointCloud2 >  StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data 
UniformSampling  UniformSampling assembles a local 3D grid over a given PointCloud, and downsamples + filters the data 
Leaf  Simple structure to hold an nD centroid and the number of points in a leaf 
VoxelGrid  VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data 
VoxelGrid< pcl::PCLPointCloud2 >  VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data 
VoxelGridCovariance  A searchable voxel strucure containing the mean and covariance of the data 
Leaf  Simple structure to hold a centroid, covarince and the number of points in a leaf 
VoxelGridLabel  
VoxelGridOcclusionEstimation  VoxelGrid to estimate occluded space in the scene 
LineIterator  Organized Index Iterator for iterating over the "pixels" for a given line using the Bresenham algorithm 
OrganizedIndexIterator  Base class for iterators on 2dimensional maps like images/organized clouds etc 
PlanarPolygon  PlanarPolygon represents a planar (2D) polygon, potentially in a 3D space 
TSDFVolume  
Header  Structure storing voxel grid resolution, volume size (in mm) and element_size of stored data 
Intr  Camera intrinsics structure 
AdaptiveRangeCoder  AdaptiveRangeCoder compression class 
StaticRangeCoder  StaticRangeCoder compression class 
ASCIIReader  Ascii Point Cloud Reader 
DavidSDKGrabber  Grabber for davidSDK structured light compliant devices 
DepthSenseGrabber  Grabber for DepthSense devices (e.g 
DinastGrabber  Grabber for DINAST devices (i.e., IPA1002, IPA1110, IPA2001) 
EnsensoGrabber  Grabber for IDSImaging Ensenso's devices 
FileGrabber  FileGrabber provides a containerstyle interface for grabbers which operate on fixedsize input 
FileReader  Point Cloud Data (FILE) file format reader interface 
FileWriter  Point Cloud Data (FILE) file format writer 
Grabber  Grabber interface for PCL 1.x device drivers 
HDLGrabber  Grabber for the Velodyne HighDefinitionLaser (HDL) 
HDLDataPacket  
HDLFiringData  
HDLLaserCorrection  
HDLLaserReturn  
IFSReader  Indexed Face set (IFS) file format reader 
IFSWriter  Point Cloud Data (IFS) file format writer 
ImageGrabberBase  Base class for Image file grabber 
ImageGrabber  
SynchronizedQueue  
MTLReader  
OBJReader  
ONIGrabber  A simple ONI grabber 
OpenNIGrabber  Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live) 
modeComp  
PCDGrabberBase  Base class for PCD file grabber 
PCDGrabber  
PCDReader  Point Cloud Data (PCD) file format reader 
PCDWriter  Point Cloud Data (PCD) file format writer 
PLYReader  Point Cloud Data (PLY) file format reader 
PLYWriter  Point Cloud Data (PLY) file format writer 
RealSenseGrabber  
Mode  A descriptor for capturing mode 
RobotEyeGrabber  Grabber for the Ocular Robotics RobotEye sensor 
VLPGrabber  Grabber for the Velodyne LiDAR (VLP), based on the Velodyne High Definition Laser (HDL) 
KdTree  KdTree represents the base spatial locator class for kdtree implementations 
KdTreeFLANN  KdTreeFLANN is a generic type of 3D spatial locator using kDtree structures 
AgastKeypoint2DBase  Detects 2D AGAST corner points 
AgastKeypoint2D  Detects 2D AGAST corner points 
AgastKeypoint2D< pcl::PointXYZ, pcl::PointUV >  Detects 2D AGAST corner points 
BriskKeypoint2D  Detects BRISK interest points based on the original code and paper reference by 
HarrisKeypoint2D  HarrisKeypoint2D detects Harris corners family points 
HarrisKeypoint3D  HarrisKeypoint3D uses the idea of 2D Harris keypoints, but instead of using image gradients, it uses surface normals 
HarrisKeypoint6D  Keypoint detector for detecting corners in 3D (XYZ), 2D (intensity) AND mixed versions of these 
ISSKeypoint3D  ISSKeypoint3D detects the Intrinsic Shape Signatures keypoints for a given point cloud 
NarfKeypoint  NARF (Normal Aligned Radial Feature) keypoints 
Parameters  Parameters used in this class 
SIFTKeypointFieldSelector  
SIFTKeypointFieldSelector< PointNormal >  
SIFTKeypointFieldSelector< PointXYZRGB >  
SIFTKeypointFieldSelector< PointXYZRGBA >  
SIFTKeypoint  SIFTKeypoint detects the Scale Invariant Feature Transform keypoints for a given point cloud dataset containing points and intensity 
SmoothedSurfacesKeypoint  Based on the paper: Xinju Li and Igor Guskov Multiscale features for approximate alignment of pointbased surfaces Proceedings of the third Eurographics symposium on Geometry processing July 2005, Vienna, Austria 
SUSANKeypoint  SUSANKeypoint implements a RGBD extension of the SUSAN detector inluding normal directions variation in top of intensity variation 
TrajkovicKeypoint2D  TrajkovicKeypoint2D implements Trajkovic and Hedley corner detector on organized pooint cloud using intensity information 
TrajkovicKeypoint3D  TrajkovicKeypoint3D implements Trajkovic and Hedley corner detector on point cloud using geometric information 
BranchEstimator  Interface for branch estimators 
BinaryTreeThresholdBasedBranchEstimator  Branch estimator for binary trees where the branch is computed only from the threshold 
TernaryTreeMissingDataBranchEstimator  Branch estimator for ternary trees where one branch is used for missing data (indicated by flag != 0) 
DenseCrf  
DecisionForest  Class representing a decision forest 
DecisionForestEvaluator  Utility class for evaluating a decision forests 
DecisionForestTrainer  Trainer for decision trees 
DecisionTree  Class representing a decision tree 
DecisionTreeTrainerDataProvider  
DecisionTreeEvaluator  Utility class for evaluating a decision tree 
DecisionTreeTrainer  Trainer for decision trees 
FeatureHandler  Utility class interface which is used for creating and evaluating features 
Fern  Class representing a Fern 
FernEvaluator  Utility class for evaluating a fern 
FernTrainer  Trainer for a Fern 
Kmeans  Kmeans clustering 
MultiChannel2DComparisonFeature  Feature for comparing two sample points in 2D multichannel data 
MultiChannel2DComparisonFeatureHandler  Feature utility class that handles the creation and evaluation of RGBD comparison features 
ScaledMultiChannel2DComparisonFeatureHandler  Feature utility class that handles the creation and evaluation of RGBD comparison features 
ScaledMultiChannel2DComparisonFeatureHandlerCCodeGenerator  
MultiChannel2DData  Holds twodimensional multichannel data 
MultiChannel2DDataSet  Holds a set of twodimensional multichannel data 
MultipleData2DExampleIndex  Example index for a set of 2D data blocks 
PairwisePotential  
Permutohedral  Implementation of a highdimensional gaussian filtering using the permutohedral lattice 
Neighbors  
HashTableOLD  
PointXY32f  2D point with float x and ycoordinates 
PointXY32i  2D point with integer x and ycoordinates 
RegressionVarianceNode  Node for a regression trees which optimizes variance 
RegressionVarianceStatsEstimator  Statistics estimator for regression trees which optimizes variance 
StatsEstimator  Class interface for gathering statistics for decision tree learning 
SVMParam  The structure stores the parameters for the classificationa nd must be initialized and passed to the training method pcl::SVMTrain 
SVMModel  The structure initialize a model crated by the SVM (Support Vector Machines) classifier (pcl::SVMTrain) 
SVMDataPoint  The structure initialize a single feature value for the classification using SVM (Support Vector Machines) 
SVMData  The structure stores the features and the label of a single sample which has to be used for the training or the classification of the SVM (Support Vector Machines) 
SVM  Base class for SVM SVM (Support Vector Machines) 
SVMTrain  SVM (Support Vector Machines) training class for the SVM machine learning 
SVMClassify  SVM (Support Vector Machines) classification of a dataset 
CorrespondenceGrouping  Abstract base class for Correspondence Grouping algorithms 
GeometricConsistencyGrouping  Class implementing a 3D correspondence grouping enforcing geometric consistency among feature correspondences 
Hough3DGrouping  Class implementing a 3D correspondence grouping algorithm that can deal with multiple instances of a model template found into a given scene 
ColorGradientDOTModality  
Candidate  
ColorGradientModality  Modality based on maxRGB gradients 
Candidate  Candidate for a feature (used in feature extraction methods) 
ColorModality  
Candidate  
CRHAlignment  CRHAlignment uses two Camera Roll Histograms (CRH) to find the roll rotation that aligns both views 
DenseQuantizedSingleModTemplate  
DenseQuantizedMultiModTemplate  
DistanceMap  Represents a distance map obtained from a distance transformation 
DOTModality  
DOTMODDetection  
DOTMOD  Template matching using the DOTMOD approach 
RFFaceDetectorTrainer  
GreedyVerification  A greedy hypothesis verification method 
GlobalHypothesesVerification  A hypothesis verification method proposed in "A Global Hypotheses Verification Method for 3D Object Recognition", A 
PapazovHV  A hypothesis verification method proposed in "An Efficient RANSAC for 3D Object Recognition in Noisy and Occluded Scenes", C 
HypothesisVerification  Abstract class for hypotheses verification methods 
ISMPeak  This struct is used for storing peak 
BoundingBoxXYZ  
LineRGBD  Highlevel class for template matching using the LINEMOD approach based on RGB and Depth data 
Detection  A LineRGBD detection 
EnergyMaps  Stores a set of energy maps 
LinearizedMaps  Stores a set of linearized maps 
LINEMODDetection  Represents a detection of a template using the LINEMOD approach 
LINEMOD  Template matching using the LINEMOD approach 
MaskMap  
GradientXY  A point structure representing Euclidean xyz coordinates, and the intensity value 
QuantizableModality  Interface for a quantizable modality 
QuantizedMap  
RegionXY  Defines a region in XYspace 
QuantizedMultiModFeature  Feature that defines a position and quantized value in a specific modality 
SparseQuantizedMultiModTemplate  A multimodality template constructed from a set of quantized multimodality features 
LINEMOD_OrientationMap  Map that stores orientations 
QuantizedNormalLookUpTable  Lookuptable for fast surface normal quantization 
SurfaceNormalModality  Modality based on surface normals 
Candidate  Candidate for a feature (used in feature extraction methods) 
SolverDidntConvergeException  An exception that is thrown when the non linear solver didn't converge 
NotEnoughPointsException  An exception that is thrown when the number of correspondents is not equal to the minimum required 
GeneralizedIterativeClosestPoint  GeneralizedIterativeClosestPoint is an ICP variant that implements the generalized iterative closest point algorithm as described by Alex Segal et al 
OptimizationFunctorWithIndices  Optimization functor structure 
_PointXYZLAB  
PointXYZLAB  A custom point type for position and CIELAB color value 
GraphRegistration  GraphRegistration class is the base class for graphbased registration methods 
SampleConsensusInitialAlignment  SampleConsensusInitialAlignment is an implementation of the initial alignment algorithm described in section IV of "Fast Point Feature Histograms (FPFH) for 3D Registration," Rusu et al 
ErrorFunctor  
HuberPenalty  
TruncatedError  
IterativeClosestPoint  IterativeClosestPoint provides a base implementation of the Iterative Closest Point algorithm 
IterativeClosestPointWithNormals  IterativeClosestPointWithNormals is a special case of IterativeClosestPoint, that uses a transformation estimated based on Point to Plane distances by default 
IterativeClosestPointNonLinear  IterativeClosestPointNonLinear is an ICP variant that uses LevenbergMarquardt optimization backend 
JointIterativeClosestPoint  JointIterativeClosestPoint extends ICP to multiple frames which share the same transform 
NormalDistributionsTransform  A 3D Normal Distribution Transform registration implementation for point cloud data 
NormalDistributionsTransform2D  NormalDistributionsTransform2D provides an implementation of the Normal Distributions Transform algorithm for scan matching 
PairwiseGraphRegistration  PairwiseGraphRegistration class aligns the clouds two by two 
PPFHashMapSearch  
HashKeyStruct  Data structure to hold the information for the key in the feature hash map of the PPFHashMapSearch class 
PPFRegistration  Class that registers two point clouds based on their sets of PPFSignatures 
PoseWithVotes  Structure for storing a pose (represented as an Eigen::Affine3f) and an integer for counting votes 
PyramidFeatureHistogram  Class that compares two sets of features by using a multiscale representation of the features inside a pyramid 
Registration  Registration represents the base registration class for general purpose, ICPlike methods 
SampleConsensusPrerejective  Pose estimation and alignment class using a prerejective RANSAC routine 
LeastMedianSquares  LeastMedianSquares represents an implementation of the LMedS (Least Median of Squares) algorithm 
MaximumLikelihoodSampleConsensus  MaximumLikelihoodSampleConsensus represents an implementation of the MLESAC (Maximum Likelihood Estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S 
MEstimatorSampleConsensus  MEstimatorSampleConsensus represents an implementation of the MSAC (Mestimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S 
ProgressiveSampleConsensus  RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Matching with PROSAC â€“ Progressive Sample Consensus", Chum, O 
RandomSampleConsensus  RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography", Martin A 
RandomizedMEstimatorSampleConsensus  RandomizedMEstimatorSampleConsensus represents an implementation of the RMSAC (Randomized Mestimator SAmple Consensus) algorithm, which basically adds a Td,d test (see RandomizedRandomSampleConsensus) to an MSAC estimator (see MEstimatorSampleConsensus) 
RandomizedRandomSampleConsensus  RandomizedRandomSampleConsensus represents an implementation of the RRANSAC (Randomized RAndom SAmple Consensus), as described in "Randomized RANSAC with Td,d test", O 
SampleConsensus  SampleConsensus represents the base class 
SampleConsensusModel  SampleConsensusModel represents the base model class 
SampleConsensusModelFromNormals  SampleConsensusModelFromNormals represents the base model class for models that require the use of surface normals for estimation 
Functor  Base functor all the models that need non linear optimization must define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec) or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) dependening on the choosen _Scalar 
SampleConsensusModelCircle2D  SampleConsensusModelCircle2D defines a model for 2D circle segmentation on the XY plane 
SampleConsensusModelCircle3D  SampleConsensusModelCircle3D defines a model for 3D circle segmentation 
SampleConsensusModelCone  SampleConsensusModelCone defines a model for 3D cone segmentation 
SampleConsensusModelCylinder  SampleConsensusModelCylinder defines a model for 3D cylinder segmentation 
SampleConsensusModelLine  SampleConsensusModelLine defines a model for 3D line segmentation 
SampleConsensusModelNormalParallelPlane  SampleConsensusModelNormalParallelPlane defines a model for 3D plane segmentation using additional surface normal constraints 
SampleConsensusModelNormalPlane  SampleConsensusModelNormalPlane defines a model for 3D plane segmentation using additional surface normal constraints 
SampleConsensusModelNormalSphere  SampleConsensusModelNormalSphere defines a model for 3D sphere segmentation using additional surface normal constraints 
SampleConsensusModelParallelLine  SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular constraints 
SampleConsensusModelParallelPlane  SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional angular constraints 
SampleConsensusModelPerpendicularPlane  SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional angular constraints 
SampleConsensusModelPlane  SampleConsensusModelPlane defines a model for 3D plane segmentation 
SampleConsensusModelRegistration  SampleConsensusModelRegistration defines a model for PointToPoint registration outlier rejection 
SampleConsensusModelRegistration2D  SampleConsensusModelRegistration2D defines a model for PointToPoint registration outlier rejection using distances between 2D pixels 
SampleConsensusModelSphere  SampleConsensusModelSphere defines a model for 3D sphere segmentation 
SampleConsensusModelStick  SampleConsensusModelStick defines a model for 3D stick segmentation 
ApproximateProgressiveMorphologicalFilter  Implements the Progressive Morphological Filter for segmentation of ground points 
Comparator  Comparator is the base class for comparators that compare two points given some function 
ConditionalEuclideanClustering  ConditionalEuclideanClustering performs segmentation based on Euclidean distance and a userdefined clustering condition 
CPCSegmentation  A segmentation algorithm partitioning a supervoxel graph 
CrfNormalSegmentation  
CrfSegmentation  
EdgeAwarePlaneComparator  EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, for use in planar segmentation 
EuclideanClusterComparator  EuclideanClusterComparator is a comparator used for finding clusters based on euclidian distance 
EuclideanClusterComparator< PointT, PointLT, deprecated::T >  
EuclideanPlaneCoefficientComparator  EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation 
EuclideanClusterExtraction  EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense 
LabeledEuclideanClusterExtraction  LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info 
ExtractPolygonalPrismData  ExtractPolygonalPrismData uses a set of point indices that represent a planar model, and together with a given height, generates a 3D polygonal prism 
GrabCut  Implementation of the GrabCut segmentation in "GrabCut â€” Interactive Foreground Extraction using Iterated Graph Cuts" by Carsten Rother, Vladimir Kolmogorov and Andrew Blake 
NLinks  
GroundPlaneComparator  GroundPlaneComparator is a Comparator for detecting smooth surfaces suitable for driving 
LCCPSegmentation  A simple segmentation algorithm partitioning a supervoxel graph into groups of locally convex connected supervoxels separated by concave borders 
OrganizedConnectedComponentSegmentation  OrganizedConnectedComponentSegmentation allows connected components to be found within organized point cloud data, given a comparison function 
OrganizedMultiPlaneSegmentation  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 
PlanarPolygonFusion  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 
PlanarRegion  PlanarRegion represents a set of points that lie in a plane 
PlaneCoefficientComparator  PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation 
PlaneRefinementComparator  PlaneRefinementComparator is a Comparator that operates on plane coefficients, for use in planar segmentation 
ProgressiveMorphologicalFilter  Implements the Progressive Morphological Filter for segmentation of ground points 
Region3D  Region3D represents summary statistics of a 3D collection of points 
RegionGrowing  Implements the well known Region Growing algorithm used for segmentation 
RegionGrowingRGB  Implements the well known Region Growing algorithm used for segmentation based on color of points 
RGBPlaneCoefficientComparator  RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation 
SACSegmentation  SACSegmentation represents the Nodelet segmentation class for Sample Consensus methods and models, in the sense that it just creates a Nodelet wrapper for genericpurpose SACbased segmentation 
SACSegmentationFromNormals  SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and models that require the use of surface normals for estimation 
SeededHueSegmentation  SeededHueSegmentation 
SegmentDifferences  SegmentDifferences obtains the difference between two spatially aligned point clouds and returns the difference between them for a maximum given distance threshold 
Supervoxel  Supervoxel container class  stores a cluster extracted using supervoxel clustering 
SupervoxelClustering  Implements a supervoxel algorithm based on voxel structure, normals, and rgb values 
VoxelData  VoxelData is a structure used for storing data within a pcl::octree::OctreePointCloudAdjacencyContainer 
UnaryClassifier  
DigitalElevationMapBuilder  Build a Digital Elevation Map in the columndisparity space from a disparity map and a color image of the scene 
DisparityMapConverter  Compute point cloud from the disparity map 
StereoGrabberBase  Base class for Stereo file grabber 
StereoGrabber  
StereoMatching  Stereo Matching abstract class 
GrayStereoMatching  Stereo Matching abstract class for Grayscale images 
BlockBasedStereoMatching  Block based (or fixed window) Stereo Matching class 
AdaptiveCostSOStereoMatching  Adaptive Cost 2pass Scanline Optimization Stereo Matching class 
BilateralUpsampling  Bilateral filtering implementation, based on the following paper: 
ConcaveHull  ConcaveHull (alpha shapes) using libqhull library 
ConvexHull  ConvexHull using libqhull library 
EarClipping  The ear clipping triangulation algorithm 
GreedyProjectionTriangulation  GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points based on local 2D projections 
GridProjection  Grid projection surface reconstruction method 
Leaf  Data leaf 
MarchingCubes  The marching cubes surface reconstruction algorithm 
MarchingCubesHoppe  The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance from tangent planes, proposed by Hoppe et 
MarchingCubesRBF  The marching cubes surface reconstruction algorithm, using a signed distance function based on radial basis functions 
MLSResult  Data structure used to store the results of the MLS fitting 
MLSProjectionResults  Data structure used to store the MLS projection results 
PolynomialPartialDerivative  Data structure used to store the MLS polynomial partial derivatives 
MovingLeastSquares  MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm for data smoothing and improved normal estimation 
MLSVoxelGrid  A minimalistic implementation of a voxel grid, necessary for the point cloud upsampling 
Leaf  
OrganizedFastMesh  Simple triangulation/surface reconstruction for organized point clouds 
Poisson  The Poisson surface reconstruction algorithm 
CloudSurfaceProcessing  CloudSurfaceProcessing represents the base class for algorithms that takes a point cloud as input and produces a new output cloud that has been modified towards a better surface representation 
MeshProcessing  MeshProcessing represents the base class for mesh processing algorithms 
PCLSurfaceBase  Pure abstract class 
SurfaceReconstruction  SurfaceReconstruction represents a base surface reconstruction class 
MeshConstruction  MeshConstruction represents a base surface reconstruction class 
SurfelSmoothing  
TextureMapping  The texture mapping algorithm 
MeshQuadricDecimationVTK  PCL mesh decimation based on vtkQuadricDecimation from the VTK library 
MeshSmoothingLaplacianVTK  PCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library 
MeshSmoothingWindowedSincVTK  PCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library 
MeshSubdivisionVTK  PCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library 
VTKUtils  
RegistrationVisualizer  RegistrationVisualizer represents the base class for rendering the intermediate positions occupied by the source point cloud during it's registration to the target point cloud 
pcl_cuda  
Filter  Removes points with x, y, or z equal to NaN 
isFiniteAOS  Check if a specific point is valid or not 
isFiniteSOA  Check if a specific point is valid or not 
isFiniteZIPSOA  Check if a specific point is valid or not 
PassThrough  PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints 
PassThrough< PointCloudAOS< Device > >  
PassThrough< PointCloudSOA< Device > >  
VoxelGrid  VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data 
VoxelGrid< PointCloudAOS< Device > >  
VoxelGrid< PointCloudSOA< Device > >  
MEstimatorSampleConsensus  
std  
traits  
has_field  Metafunction to check if a given point type has a given field 
has_all_fields  Metafunction to check if a given point type has all given fields 
has_any_field  Metafunction to check if a given point type has any of the given fields 
has_xyz  Metafunction to check if a given point type has x, y, and z fields 
has_normal  Metafunction to check if a given point type has normal_x, normal_y, and normal_z fields 
has_curvature  Metafunction to check if a given point type has curvature field 
has_intensity  Metafunction to check if a given point type has intensity field 
has_color  Metafunction to check if a given point type has either rgb or rgba field 
has_label  Metafunction to check if a given point type has label field 
Ui  
__pixAdd_CN  
__pixAdd_CN< Tin, Tout, 1 >  
__pixAdd_CN< Tin, Tout, 3 >  
__pixAdd_CN< Tin, Tout, 4 >  
__pixColorConv  
__pixColorConv< NCVColorSpaceGray, NCVColorSpaceRGBA, Tin, Tout >  
__pixColorConv< NCVColorSpaceRGBA, NCVColorSpaceGray, Tin, Tout >  
__pixDemoteClampNN_CN  
__pixDemoteClampNN_CN< Tin, Tout, 1 >  
__pixDemoteClampNN_CN< Tin, Tout, 3 >  
__pixDemoteClampNN_CN< Tin, Tout, 4 >  
__pixDemoteClampZ_CN  
__pixDemoteClampZ_CN< Tin, Tout, 1 >  
__pixDemoteClampZ_CN< Tin, Tout, 3 >  
__pixDemoteClampZ_CN< Tin, Tout, 4 >  
__pixDist_CN  
__pixDist_CN< Tin, Tout, 1 >  
__pixDist_CN< Tin, Tout, 3 >  
__pixDist_CN< Tin, Tout, 4 >  
__pixScale_CN  
__pixScale_CN< Tin, Tout, Tw, 1 >  
__pixScale_CN< Tin, Tout, Tw, 3 >  
__pixScale_CN< Tin, Tout, Tw, 4 >  
AbstractMetadata  Abstract interface for outofcore metadata file types 
Axes  
BFGS  BFGS stands for Broydenâ€“Fletcherâ€“Goldfarbâ€“Shanno (BFGS) method for solving unconstrained nonlinear optimization problems 
Parameters  
BFGSDummyFunctor  
buffer_traits  
buffer_traits< double >  
buffer_traits< float >  
Camera  
CameraPoseProcessor  Interface to extract camera pose data generated by the pcl_kinfu_app program 
CameraPoseWriter  CameraPoseWriter writes all camera poses computed by the KinfuTracker to a file on disk 
cJSON  
cJSON_Hooks  
cloud_point_index_idx  
code  
ct_data_s  
DataGenerator  
ConvPoint  
DeprecatedType  A dummy type to aid in template parameter deprecation 
Evaluation  Class for RGBD SLAM Dataset and Benchmark 
FieldMatches< PointT, fields::rgb >  
functorAddValues  
functorMaxValues  
functorMinValues  
Geometry  
Grid  
gz_header_s  
HaarClassifierCascadeDescriptor  Classifier cascade descriptor 
HaarClassifierNode128  
HaarClassifierNodeDescriptor32  
HaarFeature64  
HaarFeatureDescriptor32  
HaarStage64  
INCVMemAllocator  INCVMemAllocator (Interface) 
inflate_state  
internal_state  
kiss_fft_cpx  
kiss_fft_state  
LRUCache  
LRUCacheItem  
Mesh  
MonitorQueue  
NCVMatrix  NCVMatrix (2D) 
NCVMatrixAlloc  NCVMatrixAlloc 
NCVMatrixReuse  NCVMatrixReuse 
NCVMemNativeAllocator  NCVMemNativeAllocator 
NCVMemPtr  NCVMemPtr 
NCVMemSegment  NCVMemSegment 
NCVMemStackAllocator  NCVMemStackAllocator 
NcvPoint2D32s  
NcvPoint2D32u  
NcvRect32s  
NcvRect32u  
NcvRect8u  
NcvSize32s  
NcvSize32u  
NCVVector  NCVVector (1D) 
NCVVectorAlloc  NCVVectorAlloc 
NCVVectorReuse  NCVVectorReuse 
NppStInterpolationState  Frame interpolation state 
Object  
ObjectFeatures  
ObjectModel  
ObjectRecognition  
ObjectRecognitionParameters  
ON_2dexMap  
ON_2dPoint  
ON_2dPointArray  
ON_2dVector  
ON_2dVectorArray  
ON_2fPoint  
ON_2fPointArray  
ON_2fVector  
ON_2fVectorArray  
ON_3DM_BIG_CHUNK  
ON_3DM_CHUNK  
ON_3dmAnnotationSettings  
ON_3dmApplication  
ON_3dmConstructionPlane  
ON_3dmConstructionPlaneGridDefaults  
ON_3dmGoo  
ON_3dmIOSettings  
ON_3dmNotes  
ON_3dmObjectAttributes  
ON_3dmPageSettings  
ON_3dmProperties  
ON_3dmRenderSettings  
ON_3dmRevisionHistory  
ON_3dmSettings  
ON_3dmUnitsAndTolerances  
ON_3dmView  
ON_3dmViewPosition  
ON_3dmViewTraceImage  
ON_3dmWallpaperImage  
ON_3dPoint  
ON_3dPointArray  
ON_3dRay  
ON_3dVector  
ON_3dVectorArray  
ON_3fPoint  
ON_3fPointArray  
ON_3fVector  
ON_3fVectorArray  
ON_4dPoint  
ON_4dPointArray  
ON_4fPoint  
ON_4fPointArray  
ON_AngularDimension  
ON_AngularDimension2  
ON_Annotation  
ON_Annotation2  
ON_Annotation2Text  
ON_AnnotationArrow  
ON_AnnotationTextDot  
ON_Arc  
ON_ArcCurve  
ON_Base64EncodeStream  
ON_BezierCage  
ON_BezierCageMorph  
ON_BezierCurve  
ON_BezierSurface  
ON_BinaryArchive  
ON_BinaryArchiveBuffer  
ON_BinaryFile  
ON_Bitmap  
ON_BoundingBox  
ON_Box  
ON_Brep  
ON_BrepEdge  
ON_BrepEdgeArray  
ON_BrepFace  
ON_BrepFaceArray  
ON_BrepFaceSide  
ON_BrepFaceSideArray  
ON_BrepLoop  
ON_BrepLoopArray  
ON_BrepRegion  
ON_BrepRegionArray  
ON_BrepRegionTopology  
ON_BrepTrim  
ON_BrepTrimArray  
ON_BrepTrimPoint  
ON_BrepVertex  
ON_BrepVertexArray  
ON_Buffer  
ON_BumpFunction  
ON_CageMorph  
ON_CheckSum  
ON_Circle  
ON_ClassArray  
ON_ClassId  
ON_ClippingPlane  
ON_ClippingPlaneInfo  
ON_ClippingPlaneSurface  
ON_ClippingRegion  
ON_Color  
ON_CompressedBuffer  
ON_CompressStream  
ON_Cone  
ON_Curve  
ON_CurveArray  
ON_CurveOnSurface  
ON_CurveProxy  
ON_CurveProxyHistory  
ON_Cylinder  
ON_DecodeBase64  
ON_DetailView  
ON_DimensionExtra  
ON_DimStyle  
ON_DisplayMaterialRef  
ON_DocumentUserStringList  
ON_EarthAnchorPoint  
ON_Ellipse  
ON_EmbeddedBitmap  
ON_EmbeddedFile  
ON_Evaluator  
ON_Extrusion  
ON_FileIterator  
ON_FileStream  
ON_FixedSizePool  
ON_FixedSizePoolIterator  
ON_Font  
ON_Geometry  
ON_Group  
ON_Hatch  
ON_HatchLine  
ON_HatchLoop  
ON_HatchPattern  
ON_HistoryRecord  
ON_InstanceDefinition  
ON_InstanceRef  
ON_Interval  
ON_Layer  
ON_Leader  
ON_Leader2  
ON_Light  
ON_Line  
ON_LinearDimension  
ON_LinearDimension2  
ON_LineCurve  
ON_Linetype  
ON_LinetypeSegment  
ON_Localizer  
ON_LocalZero1  
ON_MappingChannel  
ON_MappingRef  
ON_MappingTag  
ON_Material  
ON_MaterialRef  
ON_Matrix  
ON_Mesh  
ON_MeshCurvatureStats  
ON_MeshCurveParameters  
ON_MeshEdgeRef  
ON_MeshFace  
ON_MeshFaceRef  
ON_MeshFaceSide  
ON_MeshNgon  
ON_MeshNgonList  
ON_MeshParameters  
ON_MeshPart  
ON_MeshPartition  
ON_MeshTopology  
ON_MeshTopologyEdge  
ON_MeshTopologyFace  
ON_MeshTopologyVertex  
ON_MeshVertexRef  
ON_MorphControl  
ON_NurbsCage  
ON_NurbsCurve  
ON_NurbsSurface  
ON_Object  
ON_ObjectArray  
ON_ObjectRenderingAttributes  
ON_ObjRef  
ON_ObjRef_IRefID  
ON_ObjRefEvaluationParameter  
ON_OffsetSurface  
ON_OffsetSurfaceFunction  
ON_OffsetSurfaceValue  
ON_OrdinateDimension2  
ON_Plane  
ON_PlaneEquation  
ON_PlaneSurface  
ON_PlugInRef  
ON_Point  
ON_PointCloud  
ON_PointGrid  
ON_PolyCurve  
ON_PolyEdgeCurve  
ON_PolyEdgeHistory  
ON_PolyEdgeSegment  
ON_Polyline  
ON_PolylineCurve  
ON_PolynomialCurve  
ON_PolynomialSurface  
ON_RadialDimension  
ON_RadialDimension2  
ON_RANDOM_NUMBER_CONTEXT  
ON_Read3dmBufferArchive  
ON_RenderingAttributes  
ON_RevSurface  
ON_RTree  
ON_RTreeBBox  
ON_RTreeBranch  
ON_RTreeCapsule  
ON_RTreeIterator  
ON_RTreeLeaf  
ON_RTreeMemPool  
ON_RTreeNode  
ON_RTreeSearchResult  
ON_RTreeSphere  
ON_SerialNumberMap  
MAP_VALUE  
SN_ELEMENT  
ON_SimpleArray  
ON_SimpleFixedSizePool  
ON_SpaceMorph  
ON_Sphere  
ON_String  
ON_Sum  
ON_SumSurface  
ON_Surface  
ON_SurfaceArray  
ON_SurfaceCurvature  
ON_SurfaceProperties  
ON_SurfaceProxy  
ON_TensorProduct  
ON_TextDot  
ON_TextEntity  
ON_TextEntity2  
ON_TextExtra  
ON_TextLog  
ON_Texture  
ON_TextureCoordinates  
ON_TextureMapping  
ON_Torus  
ON_U  
ON_UncompressStream  
ON_UnicodeErrorParameters  
ON_UnitSystem  
ON_UnknownUserData  
ON_UserData  
ON_UserDataHolder  
ON_UserString  
ON_UserStringList  
ON_UUID  
ON_UuidIndexList  
ON_UuidList  
ON_UuidPair  
ON_UuidPairList  
ON_Viewport  
ON_WindowsBitmap  
ON_WindowsBitmapEx  
ON_WindowsBITMAPINFO  
ON_WindowsBITMAPINFOHEADER  
ON_WindowsRGBQUAD  
ON_Workspace  
ON_Write3dmBufferArchive  
ON_wString  
ON_Xform  
ONX_Model  
ONX_Model_Object  
ONX_Model_RenderLight  
ONX_Model_UserData  
OpenNICapture  
OutofcoreCloud  
CloudDataCacheItem  
PcdQueueItem  
PCLViewer  
point_index_idx  
PointIntensity  
Scene  
svm_model  
svm_node  
svm_parameter  
svm_problem  
svm_scaling  
TAccPixDist  
TAccPixDist< float1 >  
TAccPixDist< float3 >  
TAccPixDist< float4 >  
TAccPixDist< uchar1 >  
TAccPixDist< uchar3 >  
TAccPixDist< uchar4 >  
TAccPixDist< ushort1 >  
TAccPixDist< ushort3 >  
TAccPixDist< ushort4 >  
TAccPixWeighted  
TAccPixWeighted< float1 >  
TAccPixWeighted< float3 >  
TAccPixWeighted< float4 >  
TAccPixWeighted< uchar1 >  
TAccPixWeighted< uchar3 >  
TAccPixWeighted< uchar4 >  
TAccPixWeighted< ushort1 >  
TAccPixWeighted< ushort3 >  
TAccPixWeighted< ushort4 >  
tagON_2dex  
tagON_3dex  
tagON_4dex  
tagON_RECT  
TConvBase2Vec  
TConvBase2Vec< Ncv16u, 1 >  
TConvBase2Vec< Ncv16u, 3 >  
TConvBase2Vec< Ncv16u, 4 >  
TConvBase2Vec< Ncv32f, 1 >  
TConvBase2Vec< Ncv32f, 3 >  
TConvBase2Vec< Ncv32f, 4 >  
TConvBase2Vec< Ncv32u, 1 >  
TConvBase2Vec< Ncv32u, 3 >  
TConvBase2Vec< Ncv32u, 4 >  
TConvBase2Vec< Ncv64f, 1 >  
TConvBase2Vec< Ncv64f, 3 >  
TConvBase2Vec< Ncv64f, 4 >  
TConvBase2Vec< Ncv8u, 1 >  
TConvBase2Vec< Ncv8u, 3 >  
TConvBase2Vec< Ncv8u, 4 >  
TConvVec2Base  
TConvVec2Base< double1 >  
TConvVec2Base< double3 >  
TConvVec2Base< double4 >  
TConvVec2Base< float1 >  
TConvVec2Base< float3 >  
TConvVec2Base< float4 >  
TConvVec2Base< uchar1 >  
TConvVec2Base< uchar3 >  
TConvVec2Base< uchar4 >  
TConvVec2Base< uint1 >  
TConvVec2Base< uint3 >  
TConvVec2Base< uint4 >  
TConvVec2Base< ushort1 >  
TConvVec2Base< ushort3 >  
TConvVec2Base< ushort4 >  
tree_desc_s  
Viewport  
vtkSmartPointer  
vtkVertexBufferObject  
vtkVertexBufferObjectMapper  
z_stream_s 
Except where otherwise noted, the PointClouds.org web pages are licensed under Creative Commons Attribution 3.0.
Pages generated on Fri Feb 16 2018 14:54:11