Namespace List

Here is a list of all namespaces with brief descriptions:

[detail level 12345]

NBFGSSpace
►Nboost
►Ndetail
Cis_random_access< eigen_vecS >
Cis_random_access< eigen_listS >
Ceigen_vecS
Ccontainer_gen< eigen_vecS, ValueType >
Cparallel_edge_traits< eigen_vecS >
Ceigen_listS
Ccontainer_gen< eigen_listS, ValueType >
Cparallel_edge_traits< eigen_listS >
►NEigen
CPolynomialSolver< _Scalar, 2 >
CNumTraits< pcl::ndt2d::NormalDist< PointT > >
►Nflann
CL2_Simple
CIndex
CNNIndex
CL2
CMatrix
►NLoki
►NTL
CTypeAt
CTypeAt< Typelist< Head, Tail >, 0 >
CTypeAt< Typelist< Head, Tail >, i >
CNullType
CTypelist
CInt2Type
►NNcvCTprep	Compile-time assert namespace
CCT_ASSERT_FAILURE
CCT_ASSERT_FAILURE< true >
CassertTest
►NNCVRuntimeTemplateBool
CKernelCaller
CKernelCaller< TList, 0, Func >
Nopenni
►Nopenni_wrapper
CDepthImage	This class provides methods to fill a depth or disparity image
►COpenNIDevice	Class representing an astract device for OpenNI devices: Primesense PSDK, Microsoft Kinect, Asus Xtion Pro/Live
CShiftConversion
CDeviceKinect	Concrete implementation of the interface OpenNIDevice for a MS Kinect device
CDeviceONI	Concrete implementation of the interface OpenNIDevice for a virtual device playing back an ONI file
CDevicePrimesense	Concrete implementation of the interface OpenNIDevice for a Primesense device
CDeviceXtionPro	Concrete implementation of the interface OpenNIDevice for a Asus Xtion Pro device
►COpenNIDriver	Driver class implemented as Singleton
CDeviceContext
COpenNIException	General exception class
CImage	Image class containing just a reference to image meta data
CImageBayerGRBG	This class provides methods to fill a RGB or Grayscale image buffer from underlying Bayer pattern image
CImageRGB24	This class provides methods to fill a RGB or Grayscale image buffer from underlying RGB24 image
CImageYUV422	Concrete implementation of the interface Image for a YUV 422 image used by Primesense devices
CIRImage	Class containing just a reference to IR meta data
CShiftToDepthConverter	This class provides conversion of the openni 11-bit shift data to depth;
►Npcl
►Ncommon
Ninternal
CCloudGenerator
CCloudGenerator< pcl::PointXY, GeneratorT >
CIntensityFieldAccessor< pcl::PointNormal >
CIntensityFieldAccessor< pcl::PointXYZ >
CIntensityFieldAccessor< pcl::PointXYZRGB >
CIntensityFieldAccessor< pcl::PointXYZRGBA >
CIntensityFieldAccessor< pcl::PointXYZRGBNormal >
CIntensityFieldAccessor< pcl::PointXYZRGBL >
CIntensityFieldAccessor< pcl::PointXYZLAB >
CIntensityFieldAccessor< pcl::PointXYZHSV >
CIntensityFieldAccessor< pcl::PointXYZL >
CIntensityFieldAccessor< pcl::PointXYZLNormal >
CIntensityFieldAccessor< pcl::InterestPoint >
CIntensityFieldAccessor< pcl::PointWithRange >
CIntensityFieldAccessor< pcl::PointWithScale >
CIntensityFieldAccessor< pcl::PointWithViewpoint >
CIntensityFieldAccessor< pcl::PointSurfel >
CIntensityFieldAccessor
Cuniform_distribution	Uniform distribution dummy struct
Cuniform_distribution< T, std::enable_if_t< std::is_integral< T >::value > >	Uniform distribution int specialized
Cuniform_distribution< T, std::enable_if_t< std::is_floating_point< T >::value > >	Uniform distribution float specialized
Cnormal_distribution	Normal distribution
►CUniformGenerator	UniformGenerator class generates a random number from range [min, max] at each run picked according to a uniform distribution i.e each number within [min, max] has almost the same probability of being drawn
CParameters
►CNormalGenerator	NormalGenerator class generates a random number from a normal distribution specified by (mean, sigma)
CParameters
NComparisonOps
►Nconsole
CTicToc
►Ncuda
►Ndetail
CDjSets
CGraphEdge
CGraph
CSegmLinkVal
CSegmLink
CAddPoints	Simple kernel to add two points
CAddCovariances	Adds two matrices element-wise
Cconvert_point_to_float3	Simple kernel to convert a PointXYZRGB to float3
CComputeCovarianceForPoint	Kernel to compute a `‘covariance matrix’' for a single point
COrganizedRadiusSearch	Kernel to compute a radius neighborhood given a organized point cloud (aka range image cloud)
CRGB	Default RGB structure, defined as a union over 4 chars
CPCLCUDABase	PCL base class
CCovarianceMatrix	Misnamed class holding a 3x3 matrix
COpenNIRGB	Simple structure holding RGB data
CHost	Host helper class
CDevice	Device helper class
CPointCloudAOS	PointCloudAOS represents an AOS (Array of Structs) PointCloud implementation for CUDA processing
CPointCloudSOA	PointCloudSOA represents a SOA (Struct of Arrays) PointCloud implementation for CUDA processing
CPointIterator
CPointIterator< Device, T >
CPointIterator< Host, T >
CStoragePointer
CStoragePointer< Device, T >
CStoragePointer< Host, T >
CStorageAllocator
CStorageAllocator< Device, T >
CStorageAllocator< Host, T >
CPointXYZRGB	Default point xyz-rgb structure
CScopeTimeCPU	Class to measure the time spent in a scope
CScopeTimeGPU	Class to measure the time spent in a scope
CNormalEstimationKernel
CFastNormalEstimationKernel
CNormalDeviationKernel
CdownsampleIndices
CDebayerBilinear
CDebayeringDownsampling
CYUV2RGBKernel
CYUV2RGB
CDebayering
CComputeXYZ	Compute the XYZ values for a point based on disparity information
CComputeXYZRGB	Compute the XYZ and RGB values for a point based on disparity information
CDisparityToCloud	Disparity to PointCloudAOS generator
CDisparityBoundSmoothing
CDisparityClampedSmoothing
CDisparityHelperMap
CisNotZero
CisInlier	Check if a certain tuple is a point inlier
CisNotInlier
CSetColor
CChangeColor
CMultiRandomSampleConsensus	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
CRandomSampleConsensus	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
CSampleConsensus
CDeleteIndices	Check if a certain tuple is a point inlier
CisNaNPoint
CSampleConsensusModel	SampleConsensusModel represents the base model class
CCountPlanarInlier	Check if a certain tuple is a point inlier
CNewCheckPlanarInlier	Check if a certain tuple is a point inlier
CCheckPlanarInlier	Check if a certain tuple is a point inlier
CCheckPlanarInlierIndices	Check if a certain tuple is a point inlier
CCheckPlanarInlierKinectNormalIndices	Check if a certain tuple is a point inlier
CCheckPlanarInlierKinectIndices	Check if a certain tuple is a point inlier
CCheckPlanarInlierNormalIndices	Check if a certain tuple is a point inlier
CSampleConsensusModel1PointPlane	SampleConsensusModel1PointPlane defines a model for 3D plane segmentation
CCreate1PointPlaneHypothesis	Check if a certain tuple is a point inlier
CCreate1PointPlaneSampleHypothesis	Check if a certain tuple is a point inlier
Cparallel_random_generator
CSampleConsensusModelPlane	SampleConsensusModelPlane defines a model for 3D plane segmentation
CCreatePlaneHypothesis	Check if a certain tuple is a point inlier
►Ndeprecated
CT
►Ndetail
►Ntraits
CdescriptorSize
CdescriptorSize< PFHSignature125 >
CdescriptorSize< PFHRGBSignature250 >
CdescriptorSize< ShapeContext1980 >
CdescriptorSize< UniqueShapeContext1960 >
CdescriptorSize< SHOT352 >
CdescriptorSize< SHOT1344 >
CdescriptorSize< FPFHSignature33 >
CdescriptorSize< VFHSignature308 >
CdescriptorSize< GRSDSignature21 >
CdescriptorSize< BRISKSignature512 >
CdescriptorSize< ESFSignature640 >
CdescriptorSize< GASDSignature512 >
CdescriptorSize< GASDSignature984 >
CdescriptorSize< GASDSignature7992 >
CdescriptorSize< GFPFHSignature16 >
CdescriptorSize< Narf36 >
CdescriptorSize< Histogram< N > >
CAccumulatorXYZ
CAccumulatorNormal
CAccumulatorCurvature
CAccumulatorRGBA
CAccumulatorIntensity
CAccumulatorLabel
►CIsAccumulatorCompatible
Capply
CAccumulators
CAddPoint
CGetPoint
CCopyPointHelper
CCopyPointHelper< PointInT, PointOutT, std::enable_if_t< std::is_same< PointInT, PointOutT >::value > >
CCopyPointHelper< PointInT, PointOutT, std::enable_if_t< boost::mpl::and_< boost::mpl::not_< std::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 > > > >::value > >
CCopyPointHelper< PointInT, PointOutT, std::enable_if_t< boost::mpl::and_< boost::mpl::not_< std::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 > > > >::value > >
CEigenVector
CTransformer	A helper struct to apply an SO3 or SE3 transform to a 3D point
CFieldAdder
CFieldMapper
CFieldCaster
CFieldCopier	Used together with pcl::for_each_type, copies all point fields from cloud_data (respecting each field offset) to msg_data (tightly packed)
CFieldAdderAdvanced	Used together with pcl::for_each_type, creates list of all fields, and list of size of each field
CFieldMapping
Cint_type	Int_type::type refers to an integral type that satisfies template parameters
Cint_type< 8, true >
Cint_type< 8, false >
Cint_type< 16, true >
Cint_type< 16, false >
Cint_type< 32, true >
Cint_type< 32, false >
Cint_type< 64, true >
Cint_type< 64, false >
CMeshIndex
Ccompat_with_flann
Ccompat_with_flann< std::size_t >
►Ndevice
►NkinfuLS
CIntr	Camera intrinsics structure
CMat33	3x3 Matrix for device code
►CEigen33
CMiniMat
CBlock
CWarp
CEmulation
CLightSource	Light source collection
Cfloat8
Cfloat12
►CEigen33
CMiniMat
CHistogram
CPPFSignature
CPPFRGBSignature
CPrincipalCurvatures
CVFHEstimationImpl
CBlock
CWarp
CEmulation
CIntr	Camera intrinsics structure
CMat33	3x3 Matrix for device code
CLightSource	Light source collection
Cfloat8
Cfloat12
COctreeIteratorDevice
COctreeIteratorDeviceNS
COctreeGlobal
COctreeGlobalWithBox
►COctreeImpl
COctreeDataHost
CMorton
CCalcMorton
CCompareByLevelCode
COctreePriorityIteratorDevice
Cprob_histogram
CConnectedComponents
CDilatation
CCUDATree	Struct that holds a single RDF tree in GPU
CMultiTreeLiveProc	Processor using multiple trees
CProbabilityProc	Implementation Class to process probability histograms on GPU
CLessThanByFacet
CInitalSimplex
CFacetStream
CPointStream
CNonCachedLoad
Cbit_not
CplusWeighted
Ndistances
►Nexperimental
►Nadvanced
CFunctorFilter	Filter point clouds and indices based on a function object passed in the ctor
►Nface_detection
CTrainingExample
CFeatureType
CRFTreeNode
CFaceDetectorDataProvider
CFeatureHandlerDepthAverage
CPoseClassRegressionVarianceStatsEstimator	Statistics estimator for regression trees which optimizes information gain and pose parameters error
►Nfeatures
CISMVoteList	This class is used for storing, analyzing and manipulating votes obtained from ISM algorithm
CISMModel	The assignment of this structure is to store the statistical/learned weights and other information of the trained Implicit Shape Model algorithm
Nfields
►Nfilters
CConvolution	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
CConvolvingKernel	Class ConvolvingKernel base class for all convolving kernels
CGaussianKernel	Gaussian kernel implementation interface Use this as implementation reference
CGaussianKernelRGB	Gaussian kernel implementation interface with RGB channel handling Use this as implementation reference
CConvolution3D	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
CConvolvingKernel< PointT, pcl::Normal >
CConvolvingKernel< PointT, pcl::PointXY >
CPyramid	Pyramid constructs a multi-scale representation of an organised point cloud
►Ngeometry
CMeshIO	Read / write the half-edge mesh from / to a file
CMeshBase	Base class for the half-edge mesh
CVertexAroundVertexCirculator	Circulates counter-clockwise around a vertex and returns an index to the terminating vertex of the outgoing half-edge (the target)
COutgoingHalfEdgeAroundVertexCirculator	Circulates counter-clockwise around a vertex and returns an index to the outgoing half-edge (the target)
CIncomingHalfEdgeAroundVertexCirculator	Circulates counter-clockwise around a vertex and returns an index to the incoming half-edge (the target)
CFaceAroundVertexCirculator	Circulates counter-clockwise around a vertex and returns an index to the face of the outgoing half-edge (the target)
CVertexAroundFaceCirculator	Circulates clockwise around a face and returns an index to the terminating vertex of the inner half-edge (the target)
CInnerHalfEdgeAroundFaceCirculator	Circulates clockwise around a face and returns an index to the inner half-edge (the target)
COuterHalfEdgeAroundFaceCirculator	Circulates clockwise around a face and returns an index to the outer half-edge (the target)
CFaceAroundFaceCirculator	Circulates clockwise around a face and returns an index to the face of the outer half-edge (the target)
CVertex	A vertex is a node in the mesh
CHalfEdge	An edge is a connection between two vertices
CFace	A face is a closed loop of edges
CNoData	No data is associated with the vertices / half-edges / edges / faces
CDefaultMeshTraits	The mesh traits are used to set up compile time settings for the mesh
CPolygonMeshTag	Tag describing the type of the mesh
CPolygonMesh	General half-edge mesh that can store any polygon with a minimum number of vertices of 3
CQuadMeshTag	Tag describing the type of the mesh
CQuadMesh	Half-edge mesh that can only store quads
CTriangleMeshTag	Tag describing the type of the mesh
CTriangleMesh	Half-edge mesh that can only store triangles
►Ngpu
►NkinfuLS
CColorVolume	ColorVolume class
CCyclicalBuffer	CyclicalBuffer implements a cyclical TSDF buffer
CKinfuTracker	KinfuTracker class encapsulates implementation of Microsoft Kinect Fusion algorithm
CMarchingCubes	MarchingCubes implements MarchingCubes functionality for TSDF volume on GPU
CPixelRGB	Input/output pixel format for KinfuTracker
CRayCaster	Class that performs raycasting for TSDF volume
CStandaloneMarchingCubes	The Standalone Marching Cubes Class provides encapsulated functionality for the Marching Cubes implementation originally by Anatoly Baksheev
Ctsdf_buffer	Structure to handle buffer addresses
►CTsdfVolume	TsdfVolume class
CHeader	Structure storing voxel grid resolution, volume size (in mm) and element_size of data stored on host
CCaptureOpenNI
►Npeople
Nlabel_skeleton
►Ntrees
CAttribLocation
CNode
CHistogram
CHistogramPair
CSplitPoint
CLabeledAttrib
CLabeledFeature
CRDFBodyPartsDetector
CFaceDetector
CBlob2	This structure contains all parameters to describe blobs and their parent/child relations
CTree2	This structure contains all parameters to describe the segmented tree
COrganizedPlaneDetector
CPeopleDetector
CPersonAttribs
CProbabilityProcessor
CDeviceArray	DeviceArray class
CDeviceArray2D	DeviceArray2D class
CDeviceMemory	DeviceMemory class
CDeviceMemory2D	DeviceMemory2D class
CTextureBinder
CDevPtr
CPtrSz
CPtrStep
CPtrStepSz
CFeature	Feature represents the base feature class
CFeatureFromNormals	Feature represents the base feature class that takes normals as input also
CNormalEstimation	Class for normal estimation
CPFHEstimation	Class for PFH estimation
CPFHRGBEstimation	Class for PFHRGB estimation
CFPFHEstimation	Class for FPFH estimation
CPPFEstimation	**
CPPFRGBEstimation	**
CPPFRGBRegionEstimation	**
CPrincipalCurvaturesEstimation	‍**
CVFHEstimation	**
CSpinImageEstimation	‍**
►CDataSource
CNormal2PointXYZ
CColorVolume	ColorVolume class
CKinfuTracker	KinfuTracker class encapsulates implementation of Microsoft Kinect Fusion algorithm
CMarchingCubes	MarchingCubes implements MarchingCubes functionality for TSDF volume on GPU
CPixelRGB	Input/output pixel format for KinfuTracker
CRayCaster	Class that performs raycasting for TSDF volume
CTsdfVolume	TsdfVolume class
CCaptureOpenNI
CNeighborIndices
COctree	Octree implementation on GPU
CAsyncCopy
CEuclideanClusterExtraction	EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, depending on pcl::gpu::octree
CEuclideanLabeledClusterExtraction	EuclideanLabeledClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, depending on pcl::gpu::octree
CSeededHueSegmentation
CPseudoConvexHull3D
CParticleFilterGPUTracker
CTimer
CScopeTimer
►Ninternal
Ccloud_point_index_idx	Used internally in voxel grid classes
►Nio
►Ndepth_sense
CDepthSenseDeviceManager	A helper class for enumerating and managing access to DepthSense devices
CDepthSenseGrabberImpl
►Nopenni2
COpenNI2Device
COpenNI2DeviceInfo
COpenNI2DeviceManager
COpenNI2FrameListener
COpenNI2TimerFilter
COpenNI2VideoMode
►Nply
Nio_operators
Ctype_traits
►Cply_parser	Class ply_parser parses a PLY file and generates appropriate atomic parsers for the body
Clist_property_begin_callback_type
Clist_property_definition_callback_type
Clist_property_definition_callbacks_type
Clist_property_element_callback_type
Clist_property_end_callback_type
Cscalar_property_callback_type
Cscalar_property_definition_callback_type
Cscalar_property_definition_callbacks_type
►Nreal_sense
CRealSenseDeviceManager
CRealSenseDevice
CconfigurationProfile_t
COctreePointCloudCompression	Octree pointcloud compression class
COrganizedPointCloudCompression
CCompressionPointTraits
CCompressionPointTraits< PointXYZRGB >
CCompressionPointTraits< PointXYZRGBA >
COrganizedConversion
COrganizedConversion< PointT, false >
COrganizedConversion< PointT, true >
CBuffer	An abstract base class for fixed-size data buffers
CSingleBuffer	A simple buffer that only stores data
CMedianBuffer	A buffer that computes running window median of the data inserted
CAverageBuffer	A buffer that computes running window average of the data inserted
CDeBayer	Various debayering methods
CImage	Image interface class providing an interface to fill a RGB or Grayscale image buffer
CDepthImage	This class provides methods to fill a depth or disparity image
CIRImage	Class containing just a reference to IR meta data
CFrameWrapper	Pure abstract interface to wrap native frame data types
CImageRGB24	This class provides methods to fill a RGB or Grayscale image buffer from underlying RGB24 image
CImageYUV422	Concrete implementation of the interface Image for a YUV 422 image used by Primesense devices
CIOException	General IO exception class
CCameraParameters	Basic camera parameters placeholder
CLZFImageReader	PCL-LZF image format reader
CLZFDepth16ImageReader	PCL-LZF 16-bit depth image format reader
CLZFRGB24ImageReader	PCL-LZF 24-bit RGB image format reader
CLZFYUV422ImageReader	PCL-LZF 8-bit Bayer image format reader
CLZFBayer8ImageReader	PCL-LZF 8-bit Bayer image format reader
CLZFImageWriter	PCL-LZF image format writer
CLZFDepth16ImageWriter	PCL-LZF 16-bit depth image format writer
CLZFRGB24ImageWriter	PCL-LZF 24-bit RGB image format writer
CLZFYUV422ImageWriter	PCL-LZF 16-bit YUV422 image format writer
CLZFBayer8ImageWriter	PCL-LZF 8-bit Bayer image format writer
CPointCloudImageExtractor	Base Image Extractor class for organized point clouds
CPointCloudImageExtractorWithScaling	Image Extractor extension which provides functionality to apply scaling to the values extracted from a field
CPointCloudImageExtractorFromNormalField	Image Extractor which uses the data present in the "normal" field
CPointCloudImageExtractorFromRGBField	Image Extractor which uses the data present in the "rgb" or "rgba" fields to produce a color image with rgb8 encoding
CPointCloudImageExtractorFromLabelField	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
CPointCloudImageExtractorFromZField	Image Extractor which uses the data present in the "z" field to produce a depth map (as a monochrome image with mono16 encoding)
CPointCloudImageExtractorFromCurvatureField	Image Extractor which uses the data present in the "curvature" field to produce a curvature map (as a monochrome image with mono16 encoding)
CPointCloudImageExtractorFromIntensityField	Image Extractor which uses the data present in the "intensity" field to produce a monochrome intensity image (with mono16 encoding)
CTARHeader	A TAR file's header, as described on https://en.wikipedia.org/wiki/Tar_%28file_format%29
►Nism
►CImplicitShapeModelEstimation	This class implements Implicit Shape Model algorithm described in "Hough Transforms and 3D SURF for robust three dimensional classification" by Jan Knopp, Mukta Prasad, Geert Willems, Radu Timofte, and Luc Van Gool
CLocationInfo	This structure stores the information about the keypoint
CTermCriteria	This structure is used for determining the end of the k-means clustering process
CVisualWordStat	Structure for storing the visual word
►Nkeypoints
►Nagast
►CAbstractAgastDetector	Abstract detector class for AGAST corner point detectors
CCompareScoreIndex	Score index comparator
CScoreIndex	Structure holding an index and the associated keypoint score
CAgastDetector7_12s	Detector class for AGAST corner point detector (7_12s)
CAgastDetector5_8	Detector class for AGAST corner point detector (5_8)
COastDetector9_16	Detector class for AGAST corner point detector (OAST 9_16)
►Nbrisk
►CLayer	A layer in the BRISK detector pyramid
CCommonParams
CScaleSpace	BRISK Scale Space helper
►Ninternal
CAgastApplyNonMaxSuppresion
CAgastApplyNonMaxSuppresion< pcl::PointUV >
CAgastDetector
CAgastDetector< pcl::PointUV >
►NkinfuLS
CScreenshotManager	Screenshot Manager saves a screenshot with the corresponding camera pose from Kinfu
CWorldModel	WorldModel maintains a 3D point cloud that can be queried and updated via helper functions
►Nndt2d
CValueAndDerivatives	Class to store vector value and first and second derivatives (grad vector and hessian matrix), so they can be returned easily from functions
CNormalDist	A normal distribution estimation class
CNDTSingleGrid	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
CNDT2D	Build a Normal Distributions Transform of a 2D point cloud
►Nocclusion_reasoning
CZBuffering	Class to reason about occlusions
►Noctree
CColorCoding	ColorCoding class
CPointCoding	PointCoding class
CBufferedBranchNode
COctree2BufBase	Octree double buffer class
COctreeBase	Octree class
COctreeContainerBase	Octree container class that can serve as a base to construct own leaf node container classes
COctreeContainerEmpty	Octree container class that does not store any information
COctreeContainerPointIndex	Octree container class that does store a single point index
COctreeContainerPointIndices	Octree container class that does store a vector of point indices
CIteratorState
COctreeIteratorBase	Abstract octree iterator class
COctreeDepthFirstIterator	Octree iterator class
COctreeBreadthFirstIterator	Octree iterator class
COctreeFixedDepthIterator	Octree iterator class
COctreeLeafNodeDepthFirstIterator	Octree leaf node iterator class
COctreeLeafNodeBreadthFirstIterator	Octree leaf node iterator class
COctreeKey	Octree key class
COctreeNodePool	Octree node pool
COctreeNode	Abstract octree node class
COctreeLeafNode	Abstract octree leaf class
COctreeBranchNode	Abstract octree branch class
COctreePointCloud	Octree pointcloud class
COctreePointCloudAdjacency	Octree pointcloud voxel class which maintains adjacency information for its voxels
COctreePointCloudAdjacencyContainer	Octree adjacency leaf container class- stores a list of pointers to neighbors, number of points added, and a DataT value
COctreePointCloudChangeDetector	Octree pointcloud change detector class
COctreePointCloudDensityContainer	Octree pointcloud density leaf node class
COctreePointCloudDensity	Octree pointcloud density class
COctreePointCloudOccupancy	Octree pointcloud occupancy class
COctreePointCloudPointVector	Octree pointcloud point vector class
COctreePointCloudSinglePoint	Octree pointcloud single point class
COctreePointCloudVoxelCentroidContainer	Octree pointcloud voxel centroid leaf node class
COctreePointCloudVoxelCentroid	Octree pointcloud voxel centroid class
►COctreePointCloudSearch	Octree pointcloud search class
CprioBranchQueueEntry	Priority queue entry for branch nodes
CprioPointQueueEntry	Priority queue entry for point candidates
►Noutofcore
COutofcoreAbstractMetadata
COutofcoreAbstractNodeContainer
COutofcoreParams
COutofcoreOctreeBase	This code defines the octree used for point storage at Urban Robotics
COutofcoreOctreeBaseNode	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.
COutofcoreOctreeDiskContainer	Class responsible for serialization and deserialization of out of core point data
COutofcoreOctreeRamContainer	Storage container class which the outofcore octree base is templated against
COutofcoreOctreeBaseMetadata	Encapsulated class to read JSON metadata into memory, and write the JSON metadata associated with the octree root node
COutofcoreBreadthFirstIterator
COutofcoreDepthFirstIterator
COutofcoreIteratorBase	Abstract octree iterator class
COutofcoreOctreeNodeMetadata	Encapsulated class to read JSON metadata into memory, and write the JSON metadata for each node
►Npeople
CGroundBasedPeopleDetectionApp	GroundBasedPeopleDetectionApp performs people detection on RGB-D data having as input the ground plane coefficients
CHeadBasedSubclustering	HeadBasedSubclustering represents a class for searching for people inside a HeightMap2D based on a 3D head detection algorithm
CHeightMap2D	HeightMap2D represents a class for creating a 2D height map from a point cloud and searching for its local maxima
CHOG	HOG represents a class for computing the HOG descriptor described in Dalal, N
CPersonClassifier
CPersonCluster	PersonCluster represents a class for representing information about a cluster containing a person
►Npoisson
CAllocatorState
CAllocator	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 stack-based manner, so that memory allocated last is released first
CBinaryNode
►CBSplineData
CBSplineComponents
CBSplineElementCoefficients
CBSplineElements
CFunctionData
CPoint3D
CEdge
CTriangle
CCoredPointIndex
CEdgeIndex
CCoredEdgeIndex
CTriangleIndex
CTriangulationEdge
CTriangulationTriangle
CTriangulation
CCoredVertexIndex
CCoredMeshData
►CCoredMeshData2
CVertex
CCoredVectorMeshData
CCoredVectorMeshData2
CCoredFileMeshData
CCoredFileMeshData2
CSquare
CCube
CMarchingSquares
CMarchingCubes
CMinimalAreaTriangulation
CRootInfo
CVertexData
►CSortedTreeNodes
CCornerIndices
CCornerTableData
CEdgeIndices
CEdgeTableData
CTreeNodeData
COctree
CUpSampleData
►COctNode
CConstNeighborKey3
CConstNeighborKey5
CConstNeighbors3
CConstNeighbors5
CNeighborKey3
CNeighborKey5
CNeighbors3
CNeighbors5
CPoissonException	A base class for all poisson exceptions which inherits from std::runtime_error
CPoissonBadArgumentException	An exception that is thrown when the arguments number or type is wrong/unhandled
CPoissonOpenMPException	An exception that is thrown when something goes wrong inside an openMP for loop
CPoissonBadInitException	An exception that is thrown when initialization fails
CPolynomial
CStartingPolynomial
CPPolynomial
CMatrixEntry
CSparseMatrix
CMapReduceVector
CSparseSymmetricMatrix
CVector
CNVector
►Nrecognition
Naux
CHoughSpace3D	HoughSpace3D is a 3D voting space
►CBVH	This class is an implementation of bounding volume hierarchies
CBoundedObject
CNode
CHypothesisBase
CHypothesis
►CModelLibrary
CModel	Stores some information about the model
►CObjRecRANSAC	This is a RANSAC-based 3D object recognition method
CHypothesisCreator
COrientedPointPair
COutput	This is an output item of the ObjRecRANSAC::recognize() method
►CORRGraph
CNode
►CORROctree	That's a very specialized and simple octree class
►CNode
CData
►CORROctreeZProjection
CPixel
CSet
►CRotationSpaceCell
CEntry
CRotationSpaceCellCreator
CRotationSpace	This is a class for a discrete representation of the rotation space based on the axis-angle representation
CRotationSpaceCreator
CRigidTransformSpace
►CSimpleOctree
CNode
CTrimmedICP
CVoxelStructure	This class is a box in R3 built of voxels ordered in a regular rectangular grid
►Nregistration
Ndetail
CConvergenceCriteria	ConvergenceCriteria represents an abstract base class for different convergence criteria used in registration loops
CCorrespondenceEstimationBase	Abstract CorrespondenceEstimationBase class
CCorrespondenceEstimation	CorrespondenceEstimation represents a simple class for determining correspondences between target and query point sets/features, using nearest neighbor search
CCorrespondenceEstimationBackProjection	CorrespondenceEstimationBackprojection computes correspondences as points in the target cloud which have minimum
CCorrespondenceEstimationNormalShooting	CorrespondenceEstimationNormalShooting computes correspondences as points in the target cloud which have minimum distance to normals computed on the input cloud
CCorrespondenceEstimationOrganizedProjection	CorrespondenceEstimationOrganizedProjection computes correspondences by projecting the source point cloud onto the target point cloud using the camera intrinsic and extrinsic parameters
CCorrespondenceRejector	CorrespondenceRejector represents the base class for correspondence rejection methods
CDataContainerInterface	DataContainerInterface provides a generic interface for computing correspondence scores between correspondent points in the input and target clouds
CDataContainer	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
CCorrespondenceRejectorDistance	CorrespondenceRejectorDistance implements a simple correspondence rejection method based on thresholding the distances between the correspondences
►CCorrespondenceRejectorFeatures	CorrespondenceRejectorFeatures implements a correspondence rejection method based on a set of feature descriptors
CFeatureContainer	An inner class containing pointers to the source and target feature clouds and the parameters needed to perform the correspondence search
CFeatureContainerInterface
CCorrespondenceRejectorMedianDistance	CorrespondenceRejectorMedianDistance implements a simple correspondence rejection method based on thresholding based on the median distance between the correspondences
CCorrespondenceRejectorOneToOne	CorrespondenceRejectorOneToOne implements a correspondence rejection method based on eliminating duplicate match indices in the correspondences
CCorrespondenceRejectionOrganizedBoundary	Implements a simple correspondence rejection measure
CCorrespondenceRejectorPoly	CorrespondenceRejectorPoly implements a correspondence rejection method that exploits low-level and pose-invariant geometric constraints between two point sets by forming virtual polygons of a user-specifiable cardinality on each model using the input correspondences
CCorrespondenceRejectorSampleConsensus	CorrespondenceRejectorSampleConsensus implements a correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers)
CCorrespondenceRejectorSampleConsensus2D	CorrespondenceRejectorSampleConsensus2D implements a pixel-based correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers)
CCorrespondenceRejectorSurfaceNormal	CorrespondenceRejectorSurfaceNormal implements a simple correspondence rejection method based on the angle between the normals at correspondent points
CCorrespondenceRejectorTrimmed	CorrespondenceRejectorTrimmed implements a correspondence rejection for ICP-like registration algorithms that uses only the best 'k' correspondences where 'k' is some estimate of the overlap between the two point clouds being registered
CCorrespondenceRejectorVarTrimmed	CorrespondenceRejectoVarTrimmed implements a simple correspondence rejection method by considering as inliers a certain percentage of correspondences with the least distances
CsortCorrespondencesByQueryIndex	sortCorrespondencesByQueryIndex : a functor for sorting correspondences by query index
CsortCorrespondencesByMatchIndex	sortCorrespondencesByMatchIndex : a functor for sorting correspondences by match index
CsortCorrespondencesByDistance	sortCorrespondencesByDistance : a functor for sorting correspondences by distance
CsortCorrespondencesByQueryIndexAndDistance	sortCorrespondencesByQueryIndexAndDistance : a functor for sorting correspondences by query index and distance
CsortCorrespondencesByMatchIndexAndDistance	sortCorrespondencesByMatchIndexAndDistance : a functor for sorting correspondences by match index and distance
CDefaultConvergenceCriteria	DefaultConvergenceCriteria represents an instantiation of ConvergenceCriteria, and implements the following criteria for registration loop evaluation:
CNullMeasurement	NullMeasurement struct
CPoseMeasurement	PoseMeasurement struct
►CELCH	ELCH (Explicit Loop Closing Heuristic) class
CVertex
CGraphHandler	GraphHandler class is a wrapper for a general SLAM graph The actual graph class must fulfill the following boost::graph concepts:
CGraphOptimizer	GraphOptimizer class; derive and specialize for each graph type
CFPCSInitialAlignment	FPCSInitialAlignment computes corresponding four point congruent sets as described in: "4-points congruent sets for robust pairwise surface registration", Dror Aiger, Niloy Mitra, Daniel Cohen-Or
CKFPCSInitialAlignment	KFPCSInitialAlignment computes corresponding four point congruent sets based on keypoints as described in: "Markerless point cloud registration with keypoint-based 4-points congruent sets", Pascal Theiler, Jan Dirk Wegner, Konrad Schindler
CIncrementalRegistration	Incremental IterativeClosestPoint class
►CLUM	Globally Consistent Scan Matching based on an algorithm by Lu and Milios
CEdgeProperties
CVertexProperties
CMatchingCandidate	Container for matching candidate consisting of
Cby_score	Sorting of candidates based on fitness score value
CMetaRegistration	Meta Registration class
CTransformationEstimation	TransformationEstimation represents the base class for methods for transformation estimation based on:
CTransformationEstimation2D	TransformationEstimation2D implements a simple 2D rigid transformation estimation (x, y, theta) for a given pair of datasets
CTransformationEstimation3Point	TransformationEstimation3Points represents the class for transformation estimation based on:
CTransformationEstimationDualQuaternion	TransformationEstimationDualQuaternion implements dual quaternion based estimation of the transformation aligning the given correspondences
►CTransformationEstimationLM	TransformationEstimationLM implements Levenberg Marquardt-based estimation of the transformation aligning the given correspondences
CFunctor	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) depending on the chosen _Scalar
COptimizationFunctor
COptimizationFunctorWithIndices
CTransformationEstimationPointToPlane	TransformationEstimationPointToPlane uses Levenberg Marquardt optimization to find the transformation that minimizes the point-to-plane distance between the given correspondences
CTransformationEstimationPointToPlaneLLS	TransformationEstimationPointToPlaneLLS implements a Linear Least Squares (LLS) approximation for minimizing the point-to-plane distance between two clouds of corresponding points with normals
CTransformationEstimationPointToPlaneLLSWeighted	TransformationEstimationPointToPlaneLLSWeighted implements a Linear Least Squares (LLS) approximation for minimizing the point-to-plane distance between two clouds of corresponding points with normals, with the possibility of assigning weights to the correspondences
►CTransformationEstimationPointToPlaneWeighted	TransformationEstimationPointToPlaneWeighted uses Levenberg Marquardt optimization to find the transformation that minimizes the point-to-plane distance between the given correspondences
CFunctor	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) depending on the chosen _Scalar
COptimizationFunctor
COptimizationFunctorWithIndices
CTransformationEstimationSVD	TransformationEstimationSVD implements SVD-based estimation of the transformation aligning the given correspondences
CTransformationEstimationSVDScale	TransformationEstimationSVD implements SVD-based estimation of the transformation aligning the given correspondences
CTransformationEstimationSymmetricPointToPlaneLLS	TransformationEstimationSymmetricPointToPlaneLLS implements a Linear Least Squares (LLS) approximation for minimizing the symmetric point-to-plane distance between two clouds of corresponding points with normals
CTransformationValidation	TransformationValidation represents the base class for methods that validate the correctness of a transformation found through TransformationEstimation
►CTransformationValidationEuclidean	TransformationValidationEuclidean computes an L2SQR norm between a source and target dataset
CMyPointRepresentation	Internal point representation uses only 3D coordinates for L2
CNullEstimate	NullEstimate struct
CPoseEstimate	PoseEstimate struct
CWarpPointRigid	Base warp point class
CWarpPointRigid3D	WarpPointRigid3D enables 3D (1D rotation + 2D translation) transformations for points
CWarpPointRigid6D	WarpPointRigid3D enables 6D (3D rotation + 3D translation) transformations for points
►Nsearch
CBruteForce	Implementation of a simple brute force search algorithm
►CFlannSearch	search::FlannSearch is a generic FLANN wrapper class for the new search interface
CFlannIndexCreator	Helper class that creates a FLANN index from a given FLANN matrix
CKdTreeIndexCreator	Creates a FLANN KdTreeSingleIndex from the given input data
CKdTreeMultiIndexCreator	Creates a FLANN KdTreeIndex of multiple randomized trees from the given input data, suitable for feature matching
CKMeansIndexCreator	Creates a FLANN KdTreeSingleIndex from the given input data
CKdTree	search::KdTree is a wrapper class which inherits the pcl::KdTree class for performing search functions using KdTree structure
COctree	search::Octree is a wrapper class which implements nearest neighbor search operations based on the pcl::octree::Octree structure
►COrganizedNeighbor	OrganizedNeighbor is a class for optimized nearest neighbor search in organized projectable point clouds, for instance from Time-Of-Flight cameras or stereo cameras
CEntry
CSearch	Generic search class
►Nsegmentation
►Ndetail
CRandomWalker	Multilabel graph segmentation using random walks
►Ngrabcut
CBoykovKolmogorov	Boost implementation of Boykov and Kolmogorov's maxflow algorithm doesn't support negative flows which makes it inappropriate for this context
CColor	Structure to save RGB colors into floats
CGaussian	Gaussian structure
CGMM
CGaussianFitter	Helper class that fits a single Gaussian to color samples
►Nsurface
CSimplificationRemoveUnusedVertices
►Ntest	Test_macros.h provide helper macros for testing vectors, matrices etc
Ninternal
►Ntexture_mapping
CCamera	Structure to store camera pose and focal length
CUvIndex	Structure that links a uv coordinate to its 3D point and face
►Ntracking
CApproxNearestPairPointCloudCoherence	ApproxNearestPairPointCloudCoherence computes coherence between two pointclouds using the approximate nearest point pairs
CPointCoherence	PointCoherence is a base class to compute coherence between the two points
CPointCloudCoherence	PointCloudCoherence is a base class to compute coherence between the two PointClouds
CDistanceCoherence	DistanceCoherence computes coherence between two points from the distance between them
CHSVColorCoherence	HSVColorCoherence computes coherence between the two points from the color difference between them
CRGBValue
C_ParticleXYZRPY
CParticleXYZRPY
C_ParticleXYZR
CParticleXYZR
C_ParticleXYRPY
CParticleXYRPY
C_ParticleXYRP
CParticleXYRP
C_ParticleXYR
CParticleXYR
CKLDAdaptiveParticleFilterTracker	KLDAdaptiveParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
CKLDAdaptiveParticleFilterOMPTracker	KLDAdaptiveParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
CNearestPairPointCloudCoherence	NearestPairPointCloudCoherence computes coherence between two pointclouds using the nearest point pairs
CNormalCoherence	NormalCoherence computes coherence between two points from the angle between their normals
CParticleFilterTracker	ParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
CParticleFilterOMPTracker	ParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method in parallel, using the OpenMP standard
CPyramidalKLTTracker	Pyramidal Kanade Lucas Tomasi tracker
CTracker	Tracker represents the base tracker class
►Ntraits
►Ndetail
CPointFieldTypes	Enumeration for different numerical types
CasEnum
CasEnum< bool >
CasEnum< std::int8_t >
CasEnum< std::uint8_t >
CasEnum< std::int16_t >
CasEnum< std::uint16_t >
CasEnum< std::int32_t >
CasEnum< std::uint32_t >
CasEnum< std::int64_t >
CasEnum< std::uint64_t >
CasEnum< float >
CasEnum< double >
CasType
CasType< detail::PointFieldTypes::BOOL >
CasType< detail::PointFieldTypes::INT8 >
CasType< detail::PointFieldTypes::UINT8 >
CasType< detail::PointFieldTypes::INT16 >
CasType< detail::PointFieldTypes::UINT16 >
CasType< detail::PointFieldTypes::INT32 >
CasType< detail::PointFieldTypes::UINT32 >
CasType< detail::PointFieldTypes::INT64 >
CasType< detail::PointFieldTypes::UINT64 >
CasType< detail::PointFieldTypes::FLOAT32 >
CasType< detail::PointFieldTypes::FLOAT64 >
Nutils
►Nvisualization
►Ncontext_items
CPoint
CLine
CCircle
CDisk
CRectangle
CFilledRectangle
CPoints
CPolygon
CText
CMarkers
Ndetails
CPointCloudColorHandlerRGBHack
CAreaPickingEvent	/brief Class representing 3D area picking events
CCloudViewer	Simple point cloud visualization class
CCloudActor
CCamera	Camera class holds a set of camera parameters together with the window pos/size
CFloatImageUtils	Provide some general functionalities regarding 2d float arrays, e.g., for visualization purposes
CRenWinInteract
CPCLHistogramVisualizer	PCL histogram visualizer main class
CImageViewerInteractorStyle	An image viewer interactor style, tailored for ImageViewer
►CImageViewer	ImageViewer is a class for 2D image visualization
CExitCallback
CExitMainLoopTimerCallback
CPCLVisualizerInteractorStyle	PCLVisualizerInteractorStyle defines an unique, custom VTK based interactory style for PCL Visualizer applications
CPCLHistogramVisualizerInteractorStyle	PCL histogram visualizer interactory style class
CKeyboardEvent	/brief Class representing key hit/release events
CMouseEvent
CFigure2D	Abstract class for storing figure information
CFPolyLine2D	Class for PolyLine
CFPoints2D	Class for storing Points
CFQuad2D	Class for storing Quads
CFPolygon2D	Class for Polygon
CFEllipticArc2D	Class for storing EllipticArc; every ellipse , circle are covered by this
CPCLPainter2D	PCL Painter2D main class
CPCLPlotter	PCL Plotter main class
CPCLVisualizer	PCL Visualizer main class
CPointCloudColorHandler	Base Handler class for PointCloud colors
CPointCloudColorHandlerRandom	Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen)
CPointCloudColorHandlerCustom	Handler for predefined user colors
CPointCloudColorHandlerRGBField	RGB handler class for colors
CPointCloudColorHandlerHSVField	HSV handler class for colors
CPointCloudColorHandlerGenericField	Generic field handler class for colors
CPointCloudColorHandlerRGBAField	RGBA handler class for colors
CPointCloudColorHandlerLabelField	Label field handler class for colors
CPointCloudColorHandler< pcl::PCLPointCloud2 >	Base Handler class for PointCloud colors
CPointCloudColorHandlerRandom< pcl::PCLPointCloud2 >	Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen)
CPointCloudColorHandlerCustom< pcl::PCLPointCloud2 >	Handler for predefined user colors
CPointCloudColorHandlerRGBField< pcl::PCLPointCloud2 >	RGB handler class for colors
CPointCloudColorHandlerHSVField< pcl::PCLPointCloud2 >	HSV handler class for colors
CPointCloudColorHandlerGenericField< pcl::PCLPointCloud2 >	Generic field handler class for colors
CPointCloudColorHandlerRGBAField< pcl::PCLPointCloud2 >	RGBA handler class for colors
CPointCloudColorHandlerLabelField< pcl::PCLPointCloud2 >	Label field handler class for colors
CPointCloudGeometryHandler	Base handler class for PointCloud geometry
CPointCloudGeometryHandlerXYZ	XYZ handler class for PointCloud geometry
CPointCloudGeometryHandlerSurfaceNormal	Surface normal handler class for PointCloud geometry
CPointCloudGeometryHandlerCustom	Custom handler class for PointCloud geometry
CPointCloudGeometryHandler< pcl::PCLPointCloud2 >	Base handler class for PointCloud geometry
CPointCloudGeometryHandlerXYZ< pcl::PCLPointCloud2 >	XYZ handler class for PointCloud geometry
CPointCloudGeometryHandlerSurfaceNormal< pcl::PCLPointCloud2 >	Surface normal handler class for PointCloud geometry
CPointCloudGeometryHandlerCustom< pcl::PCLPointCloud2 >	Custom handler class for PointCloud geometry
CPointPickingCallback
CPointPickingEvent	/brief Class representing 3D point picking events
CRangeImageVisualizer	Range image visualizer class
CPCLSimpleBufferVisualizer	PCL simple buffer visualizer main class
CPCLContextItem	Struct PCLContextItem represents our own custom version of vtkContextItem, used by the ImageViewer class
CPCLContextImageItem	Struct PCLContextImageItem a specification of vtkContextItem, used to add an image to the scene in the ImageViewer class
CPCLImageCanvasSource2D	PCLImageCanvasSource2D represents our own custom version of vtkImageCanvasSource2D, used by the ImageViewer class
►CWindow
CExitCallback
CExitMainLoopTimerCallback
CPointXYZIEdge	Point cloud containing edge information
CConvolution	A 2D convolution class
CEdge
Ckernel
CKeypoint	Keypoint represents the base class for key points
CMorphology
CCloudIterator	Iterator class for point clouds with or without given indices
►CConstCloudIterator	Iterator class for point clouds with or without given indices
CConstIteratorIdx
CDefaultConstIterator
CBivariatePolynomialT	This represents a bivariate polynomial and provides some functionality for it
CNdCentroidFunctor	Helper functor structure for n-D centroid estimation
CCentroidPoint	A generic class that computes the centroid of points fed to it
CColorLUT
CNdConcatenateFunctor	Helper functor structure for concatenate
CPointCloud	PointCloud represents the base class in PCL for storing collections of 3D points
CFeatureHistogram	Type for histograms for computing mean and variance of some floats
CGaussianKernel	Class GaussianKernel assembles all the method for computing, convolving, smoothing, gradients computing an image using a gaussian kernel
CPCA	Principal Component analysis (PCA) class
CPiecewiseLinearFunction	This provides functionalities to efficiently return values for piecewise linear function
►CPolynomialCalculationsT	This provides some functionality for polynomials, like finding roots or approximating bivariate polynomials
CParameters	Parameters used in this class
►CPosesFromMatches	Calculate 3D transformation based on point correspondences
CParameters	Parameters used in this class
►CPoseEstimate	A result of the pose estimation process
CIsBetter
CSynchronizer	/brief This template class synchronizes two data streams of different types
CStopWatch	Simple stopwatch
CScopeTime	Class to measure the time spent in a scope
CEventFrequency	A helper class to measure frequency of a certain event
CTimeTrigger	Timer class that invokes registered callback methods periodically
CTransformationFromCorrespondences	Calculates a transformation based on corresponding 3D points
CVectorAverage	Calculates the weighted average and the covariance matrix
CCorrespondence	Correspondence represents a match between two entities (e.g., points, descriptors, etc)
CPointCorrespondence3D	Representation of a (possible) correspondence between two 3D points in two different coordinate frames (e.g
CPointCorrespondence6D	Representation of a (possible) correspondence between two points (e.g
CPCLException	A base class for all pcl exceptions which inherits from std::runtime_error
CInvalidConversionException	An exception that is thrown when a PCLPointCloud2 message cannot be converted into a PCL type
CIsNotDenseException	An exception that is thrown when a PointCloud is not dense but is attempted to be used as dense
CInvalidSACModelTypeException	An exception that is thrown when a sample consensus model doesn't have the correct number of samples defined in model_types.h
CIOException	An exception that is thrown during an IO error (typical read/write errors)
CInitFailedException	An exception thrown when init can not be performed should be used in all the PCLBase class inheritants
CUnorganizedPointCloudException	An exception that is thrown when an organized point cloud is needed but not provided
CKernelWidthTooSmallException	An exception that is thrown when the kernel size is too small
CUnhandledPointTypeException
CComputeFailedException
CBadArgumentException	An exception that is thrown when the arguments number or type is wrong/unhandled
Cfor_each_type_impl
Cfor_each_type_impl< false >
Cintersect
CDefaultIterator
CIteratorIdx
C_PointXYZ
CPointXYZ	A point structure representing Euclidean xyz coordinates
C_RGB
CRGB	A structure representing RGB color information
C_Intensity
CIntensity	A point structure representing the grayscale intensity in single-channel images
C_Intensity8u
CIntensity8u	A point structure representing the grayscale intensity in single-channel images
C_Intensity32u
CIntensity32u	A point structure representing the grayscale intensity in single-channel images
C_PointXYZI	A point structure representing Euclidean xyz coordinates, and the intensity value
CPointXYZI
C_PointXYZL
CPointXYZL
CLabel
C_PointXYZRGBA
CPointXYZRGBA	A point structure representing Euclidean xyz coordinates, and the RGBA color
C_PointXYZRGB
C_PointXYZRGBL
CPointXYZRGB	A point structure representing Euclidean xyz coordinates, and the RGB color
CPointXYZRGBL
C_PointXYZLAB
CPointXYZLAB	A point structure representing Euclidean xyz coordinates, and the CIELAB color
C_PointXYZHSV
CPointXYZHSV
CPointXY	A 2D point structure representing Euclidean xy coordinates
CPointUV	A 2D point structure representing pixel image coordinates
CInterestPoint	A point structure representing an interest point with Euclidean xyz coordinates, and an interest value
C_Normal
CNormal	A point structure representing normal coordinates and the surface curvature estimate
C_Axis
CAxis	A point structure representing an Axis using its normal coordinates
C_PointNormal
CPointNormal	A point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate
C_PointXYZRGBNormal
CPointXYZRGBNormal	A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate
C_PointXYZINormal
CPointXYZINormal	A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate
C_PointXYZLNormal
CPointXYZLNormal	A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates and the surface curvature estimate
C_PointWithRange
CPointWithRange	A point structure representing Euclidean xyz coordinates, padded with an extra range float
C_PointWithViewpoint
CPointWithViewpoint	A point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen
CMomentInvariants	A point structure representing the three moment invariants
CPrincipalRadiiRSD	A point structure representing the minimum and maximum surface radii (in meters) computed using RSD
CBoundary	A point structure representing a description of whether a point is lying on a surface boundary or not
CPrincipalCurvatures	A point structure representing the principal curvatures and their magnitudes
CPFHSignature125	A point structure representing the Point Feature Histogram (PFH)
CPFHRGBSignature250	A point structure representing the Point Feature Histogram with colors (PFHRGB)
CPPFSignature	A point structure for storing the Point Pair Feature (PPF) values
CCPPFSignature	A point structure for storing the Point Pair Feature (CPPF) values
CPPFRGBSignature	A point structure for storing the Point Pair Color Feature (PPFRGB) values
CNormalBasedSignature12	A point structure representing the Normal Based Signature for a feature matrix of 4-by-3
CShapeContext1980	A point structure representing a Shape Context
CUniqueShapeContext1960	A point structure representing a Unique Shape Context
CSHOT352	A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape only
CSHOT1344	A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+color
C_ReferenceFrame	A structure representing the Local Reference Frame of a point
CReferenceFrame
CFPFHSignature33	A point structure representing the Fast Point Feature Histogram (FPFH)
CVFHSignature308	A point structure representing the Viewpoint Feature Histogram (VFH)
CGRSDSignature21	A point structure representing the Global Radius-based Surface Descriptor (GRSD)
CBRISKSignature512	A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK)
CESFSignature640	A point structure representing the Ensemble of Shape Functions (ESF)
CGASDSignature512	A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor
CGASDSignature984	A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor
CGASDSignature7992	A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor
CGFPFHSignature16	A point structure representing the GFPFH descriptor with 16 bins
CNarf36	A point structure representing the Narf descriptor
CBorderDescription	A structure to store if a point in a range image lies on a border between an obstacle and the background
CIntensityGradient	A point structure representing the intensity gradient of an XYZI point cloud
CHistogram	A point structure representing an N-D histogram
C_PointWithScale
CPointWithScale	A point structure representing a 3-D position and scale
C_PointSurfel
CPointSurfel	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
C_PointDEM
CPointDEM	A point structure representing Digital Elevation Map
CModelCoefficients
CPCLBase	PCL base class
CPCLBase< pcl::PCLPointCloud2 >
CPCLHeader
CPCLImage
CPCLPointCloud2
CPCLPointField
CFieldMatches
CNdCopyEigenPointFunctor	Helper functor structure for copying data between an Eigen type and a PointT
CNdCopyPointEigenFunctor	Helper functor structure for copying data between an Eigen type and a PointT
CPointRepresentation	PointRepresentation provides a set of methods for converting a point structs/object into an n-dimensional vector
CDefaultPointRepresentation	DefaultPointRepresentation extends PointRepresentation to define default behavior for common point types
CDefaultFeatureRepresentation	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)
CDefaultPointRepresentation< PointXYZ >
CDefaultPointRepresentation< PointXYZI >
CDefaultPointRepresentation< PointNormal >
CDefaultPointRepresentation< PFHSignature125 >
CDefaultPointRepresentation< PFHRGBSignature250 >
CDefaultPointRepresentation< PPFSignature >
CDefaultPointRepresentation< FPFHSignature33 >
CDefaultPointRepresentation< VFHSignature308 >
CDefaultPointRepresentation< GASDSignature512 >
CDefaultPointRepresentation< GASDSignature984 >
CDefaultPointRepresentation< GASDSignature7992 >
CDefaultPointRepresentation< Narf36 >
CDefaultPointRepresentation< NormalBasedSignature12 >
CDefaultPointRepresentation< ShapeContext1980 >
CDefaultPointRepresentation< UniqueShapeContext1960 >
CDefaultPointRepresentation< SHOT352 >
CDefaultPointRepresentation< SHOT1344 >
CCustomPointRepresentation	CustomPointRepresentation extends PointRepresentation to allow for sub-part selection on the point
CPointIndices
CPolygonMesh
CBearingAngleImage	Class BearingAngleImage is used as an interface to generate Bearing Angle(BA) image
CRangeImage	RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where a 3D scene was captured from a specific view point
CRangeImagePlanar	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, ToF-cameras), so that a conversion to point cloud and then to a spherical range image becomes unnecessary
CRangeImageSpherical	RangeImageSpherical is derived from the original range image and uses a slightly different spherical projection
►CTexMaterial
CRGB
CTextureMesh
CCopyIfFieldExists	A helper functor that can copy a specific value if the given field exists
CSetIfFieldExists	A helper functor that can set a specific value in a field if the field exists
Chas_custom_allocator	Tests at compile time if type T has a custom allocator
CVertices	Describes a set of vertices in a polygon mesh, by basically storing an array of indices
►COrganizedNeighborSearch	OrganizedNeighborSearch class
CnearestNeighborCandidate	nearestNeighborCandidate entry for the nearest neighbor candidate queue
CradiusSearchLoopkupEntry	radiusSearchLoopkupEntry entry for radius search lookup vector
CShapeContext3DEstimation	ShapeContext3DEstimation implements the 3D shape context descriptor as described in:
CBOARDLocalReferenceFrameEstimation	BOARDLocalReferenceFrameEstimation implements the BOrder Aware Repeatable Directions algorithm for local reference frame estimation as described here:
CBoundaryEstimation	BoundaryEstimation estimates whether a set of points is lying on surface boundaries using an angle criterion
CBRISK2DEstimation	Implementation of the BRISK-descriptor, based on the original code and paper reference by
CCPPFEstimation	Class that calculates the "surflet" features for each pair in the given pointcloud
CCRHEstimation	CRHEstimation estimates the Camera Roll Histogram (CRH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in:
CCVFHEstimation	CVFHEstimation estimates the Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in:
CDifferenceOfNormalsEstimation	A Difference of Normals (DoN) scale filter implementation for point cloud data
CESFEstimation	ESFEstimation estimates the ensemble of shape functions descriptors for a given point cloud dataset containing points
CFeature	Feature represents the base feature class
CFeatureFromNormals
CFeatureFromLabels
CFeatureWithLocalReferenceFrames	FeatureWithLocalReferenceFrames provides a public interface for descriptor extractor classes which need a local reference frame at each input keypoint
CFLARELocalReferenceFrameEstimation	FLARELocalReferenceFrameEstimation implements the Fast LocAl Reference framE algorithm for local reference frame estimation as described here:
CFPFHEstimation	FPFHEstimation estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals
CFPFHEstimationOMP	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
CGASDEstimation	GASDEstimation estimates the Globally Aligned Spatial Distribution (GASD) descriptor for a given point cloud dataset given XYZ data
CGASDColorEstimation	GASDColorEstimation estimates the Globally Aligned Spatial Distribution (GASD) descriptor for a given point cloud dataset given XYZ and RGB data
CGFPFHEstimation	GFPFHEstimation estimates the Global Fast Point Feature Histogram (GFPFH) descriptor for a given point cloud dataset containing points and labels
CGRSDEstimation	GRSDEstimation estimates the Global Radius-based Surface Descriptor (GRSD) for a given point cloud dataset containing points and normals
CIntegralImageTypeTraits
CIntegralImageTypeTraits< float >
CIntegralImageTypeTraits< char >
CIntegralImageTypeTraits< short >
CIntegralImageTypeTraits< unsigned short >
CIntegralImageTypeTraits< unsigned char >
CIntegralImageTypeTraits< int >
CIntegralImageTypeTraits< unsigned int >
CIntegralImage2D	Determines an integral image representation for a given organized data array
CIntegralImage2D< DataType, 1 >	Partial template specialization for integral images with just one channel
CIntegralImageNormalEstimation	Surface normal estimation on organized data using integral images
CIntensityGradientEstimation	IntensityGradientEstimation estimates the intensity gradient for a point cloud that contains position and intensity values
CIntensitySpinEstimation	IntensitySpinEstimation estimates the intensity-domain spin image descriptors for a given point cloud dataset containing points and intensity
CLinearLeastSquaresNormalEstimation	Surface normal estimation on dense data using a least-squares estimation based on a first-order Taylor approximation
CMomentInvariantsEstimation	MomentInvariantsEstimation estimates the 3 moment invariants (j1, j2, j3) at each 3D point
CMomentOfInertiaEstimation	Implements the method for extracting features based on moment of inertia
CMultiscaleFeaturePersistence	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
►CNarf	NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data
CFeaturePointRepresentation
►CNarfDescriptor	Computes NARF feature descriptors for points in a range image See B
CParameters
CNormalEstimation	NormalEstimation estimates local surface properties (surface normals and curvatures)at each 3D point
CNormalEstimationOMP	NormalEstimationOMP estimates local surface properties at each 3D point, such as surface normals and curvatures, in parallel, using the OpenMP standard
CNormalBasedSignatureEstimation	Normal-based feature signature estimation class
►COrganizedEdgeBase	OrganizedEdgeBase, OrganizedEdgeFromRGB, OrganizedEdgeFromNormals, and OrganizedEdgeFromRGBNormals find 3D edges from an organized point cloud data
CNeighbor
COrganizedEdgeFromRGB
COrganizedEdgeFromNormals
COrganizedEdgeFromRGBNormals
COURCVFHEstimation	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:
CPFHEstimation	PFHEstimation estimates the Point Feature Histogram (PFH) descriptor for a given point cloud dataset containing points and normals
CPFHRGBEstimation	Similar to the Point Feature Histogram descriptor, but also takes color into account
CPPFEstimation	Class that calculates the "surflet" features for each pair in the given pointcloud
CPPFRGBEstimation
CPPFRGBRegionEstimation
CPrincipalCurvaturesEstimation	PrincipalCurvaturesEstimation estimates the directions (eigenvectors) and magnitudes (eigenvalues) of principal surface curvatures for a given point cloud dataset containing points and normals
►CRangeImageBorderExtractor	Extract obstacle borders from range images, meaning positions where there is a transition from foreground to background
CLocalSurface	Stores some information extracted from the neighborhood of a point
CParameters	Parameters used in this class
CShadowBorderIndices	Stores the indices of the shadow border corresponding to obstacle borders
CRIFTEstimation	RIFTEstimation estimates the Rotation Invariant Feature Transform descriptors for a given point cloud dataset containing points and intensity
CROPSEstimation	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
CRSDEstimation	RSDEstimation estimates the Radius-based Surface Descriptor (minimal and maximal radius of the local surface's curves) for a given point cloud dataset containing points and normals
CSHOTEstimationBase	SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
CSHOTEstimation	SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
CSHOTColorEstimation	SHOTColorEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points, normals and colors
CSHOTLocalReferenceFrameEstimation	SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor
CSHOTLocalReferenceFrameEstimationOMP	SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor
CSHOTEstimationOMP	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
CSHOTColorEstimationOMP	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
CSpinImageEstimation	Estimates spin-image descriptors in the given input points
CStatisticalMultiscaleInterestRegionExtraction	Class for extracting interest regions from unstructured point clouds, based on a multi scale statistical approach
CUniqueShapeContext	UniqueShapeContext implements the Unique Shape Context Descriptor described here:
CVFHEstimation	VFHEstimation estimates the Viewpoint Feature Histogram (VFH) descriptor for a given point cloud dataset containing points and normals
CxNdCopyEigenPointFunctor	Helper functor structure for copying data between an Eigen::VectorXf and a PointT
CxNdCopyPointEigenFunctor	Helper functor structure for copying data between an Eigen::VectorXf and a PointT
CApproximateVoxelGrid	ApproximateVoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
CBilateralFilter	A bilateral filter implementation for point cloud data
CBoxClipper3D	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 a cube centered at origin and with an extend of -1 to +1 in each dimension
CClipper3D	Base class for 3D clipper objects
CPointDataAtOffset	A datatype that enables type-correct comparisons
CComparisonBase	The (abstract) base class for the comparison object
CFieldComparison	The field-based specialization of the comparison object
CPackedRGBComparison	A packed rgb specialization of the comparison object
CPackedHSIComparison	A packed HSI specialization of the comparison object
CTfQuadraticXYZComparison	A comparison whether the (x,y,z) components of a given point satisfy (p'Ap + 2v'p + c [OP] 0)
CConditionBase	Base condition class
CConditionAnd	AND condition
CConditionOr	OR condition
CConditionalRemoval	ConditionalRemoval filters data that satisfies certain conditions
CCovarianceSampling	Point Cloud sampling based on the 6D covariances
CCropBox	CropBox is a filter that allows the user to filter all the data inside of a given box
CCropBox< pcl::PCLPointCloud2 >	CropBox is a filter that allows the user to filter all the data inside of a given box
CCropHull	Filter points that lie inside or outside a 3D closed surface or 2D closed polygon, as generated by the ConvexHull or ConcaveHull classes
CExtractIndices	ExtractIndices extracts a set of indices from a point cloud
CExtractIndices< pcl::PCLPointCloud2 >	ExtractIndices extracts a set of indices from a point cloud
CFarthestPointSampling	FarthestPointSampling applies farthest point sampling using euclidean distance, starting with a random point, utilizing a naive method
►CFastBilateralFilter	Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper:
CArray3D
CFastBilateralFilterOMP	Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper:
CFilter	Filter represents the base filter class
CFilter< pcl::PCLPointCloud2 >	Filter represents the base filter class
CFilterIndices	FilterIndices represents the base class for filters that are about binary point removal
CFilterIndices< pcl::PCLPointCloud2 >	FilterIndices represents the base class for filters that are about binary point removal
CFrustumCulling	FrustumCulling filters points inside a frustum given by pose and field of view of the camera
CGridMinimum	GridMinimum assembles a local 2D grid over a given PointCloud, and downsamples the data
CLocalMaximum	LocalMaximum downsamples the cloud, by eliminating points that are locally maximal
CMedianFilter	Implementation of the median filter
CModelOutlierRemoval	ModelOutlierRemoval filters points in a cloud based on the distance between model and point
CNormalRefinement	Normal vector refinement class
CNormalSpaceSampling	NormalSpaceSampling samples the input point cloud in the space of normal directions computed at every point
CPassThrough	PassThrough passes points in a cloud based on constraints for one particular field of the point type
CPassThrough< pcl::PCLPointCloud2 >	PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints
CPlaneClipper3D	Implementation of a plane clipper in 3D
CProjectInliers	ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud
CProjectInliers< pcl::PCLPointCloud2 >	ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud
CRadiusOutlierRemoval	RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have
CRadiusOutlierRemoval< 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
CRandomSample	RandomSample applies a random sampling with uniform probability
CRandomSample< pcl::PCLPointCloud2 >	RandomSample applies a random sampling with uniform probability
CSamplingSurfaceNormal	SamplingSurfaceNormal divides the input space into grids until each grid contains a maximum of N points, and samples points randomly within each grid
CShadowPoints	ShadowPoints removes the ghost points appearing on edge discontinuties
CStatisticalOutlierRemoval	StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data
CStatisticalOutlierRemoval< pcl::PCLPointCloud2 >	StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data
►CUniformSampling	UniformSampling assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
CLeaf	Simple structure to hold an nD centroid and the number of points in a leaf
CVoxelGrid	VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
CVoxelGrid< pcl::PCLPointCloud2 >	VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
►CVoxelGridCovariance	A searchable voxel structure containing the mean and covariance of the data
CLeaf	Simple structure to hold a centroid, covarince and the number of points in a leaf
CVoxelGridLabel
CVoxelGridOcclusionEstimation	VoxelGrid to estimate occluded space in the scene
CLineIterator	Organized Index Iterator for iterating over the "pixels" for a given line using the Bresenham algorithm
COrganizedIndexIterator	Base class for iterators on 2-dimensional maps like images/organized clouds etc
CPlanarPolygon	PlanarPolygon represents a planar (2D) polygon, potentially in a 3D space
►CTSDFVolume
CHeader	Structure storing voxel grid resolution, volume size (in mm) and element_size of stored data
CIntr	Camera intrinsics structure
CAdaptiveRangeCoder	AdaptiveRangeCoder compression class
CStaticRangeCoder	StaticRangeCoder compression class
CASCIIReader	Ascii Point Cloud Reader
CDavidSDKGrabber	Grabber for davidSDK structured light compliant devices
CDepthSenseGrabber	Grabber for DepthSense devices (e.g
CDinastGrabber	Grabber for DINAST devices (i.e., IPA-1002, IPA-1110, IPA-2001)
CEnsensoGrabber	Grabber for IDS-Imaging Ensenso's devices
CFileGrabber	FileGrabber provides a container-style interface for grabbers which operate on fixed-size input
CFileReader	Point Cloud Data (FILE) file format reader interface
CFileWriter	Point Cloud Data (FILE) file format writer
CGrabber	Grabber interface for PCL 1.x device drivers
►CHDLGrabber	Grabber for the Velodyne High-Definition-Laser (HDL)
CHDLDataPacket
CHDLFiringData
CHDLLaserCorrection
CHDLLaserReturn
CIFSReader	Indexed Face set (IFS) file format reader
CIFSWriter	Point Cloud Data (IFS) file format writer
CImageGrabberBase	Base class for Image file grabber
CImageGrabber
CSynchronizedQueue
CMTLReader
COBJReader
CONIGrabber	A simple ONI grabber
►COpenNIGrabber	Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
CmodeComp
CPCDGrabberBase	Base class for PCD file grabber
CPCDGrabber
CPCDReader	Point Cloud Data (PCD) file format reader
CPCDWriter	Point Cloud Data (PCD) file format writer
CPLYReader	Point Cloud Data (PLY) file format reader
CPLYWriter	Point Cloud Data (PLY) file format writer
CRealSense2Grabber	Grabber for Intel Realsense 2 SDK devices (D400 series)
►CRealSenseGrabber
CMode	A descriptor for capturing mode
CRobotEyeGrabber	Grabber for the Ocular Robotics RobotEye sensor
CTimGrabber
CVLPGrabber	Grabber for the Velodyne LiDAR (VLP), based on the Velodyne High Definition Laser (HDL)
CKdTree	KdTree represents the base spatial locator class for kd-tree implementations
CKdTreeFLANN	KdTreeFLANN is a generic type of 3D spatial locator using kD-tree structures
CAgastKeypoint2DBase	Detects 2D AGAST corner points
CAgastKeypoint2D	Detects 2D AGAST corner points
CAgastKeypoint2D< pcl::PointXYZ, pcl::PointUV >	Detects 2D AGAST corner points
CBriskKeypoint2D	Detects BRISK interest points based on the original code and paper reference by
CHarrisKeypoint2D	HarrisKeypoint2D detects Harris corners family points
CHarrisKeypoint3D	HarrisKeypoint3D uses the idea of 2D Harris keypoints, but instead of using image gradients, it uses surface normals
CHarrisKeypoint6D	Keypoint detector for detecting corners in 3D (XYZ), 2D (intensity) AND mixed versions of these
CISSKeypoint3D	ISSKeypoint3D detects the Intrinsic Shape Signatures keypoints for a given point cloud
►CNarfKeypoint	NARF (Normal Aligned Radial Feature) keypoints
CParameters	Parameters used in this class
CSIFTKeypointFieldSelector
CSIFTKeypointFieldSelector< PointNormal >
CSIFTKeypointFieldSelector< PointXYZRGB >
CSIFTKeypointFieldSelector< PointXYZRGBA >
CSIFTKeypoint	SIFTKeypoint detects the Scale Invariant Feature Transform keypoints for a given point cloud dataset containing points and intensity
CSmoothedSurfacesKeypoint	Based on the paper: Xinju Li and Igor Guskov Multi-scale features for approximate alignment of point-based surfaces Proceedings of the third Eurographics symposium on Geometry processing July 2005, Vienna, Austria
CSUSANKeypoint	SUSANKeypoint implements a RGB-D extension of the SUSAN detector including normal directions variation in top of intensity variation
CTrajkovicKeypoint2D	TrajkovicKeypoint2D implements Trajkovic and Hedley corner detector on organized point cloud using intensity information
CTrajkovicKeypoint3D	TrajkovicKeypoint3D implements Trajkovic and Hedley corner detector on point cloud using geometric information
CBranchEstimator	Interface for branch estimators
CBinaryTreeThresholdBasedBranchEstimator	Branch estimator for binary trees where the branch is computed only from the threshold
CTernaryTreeMissingDataBranchEstimator	Branch estimator for ternary trees where one branch is used for missing data (indicated by flag != 0)
CDenseCrf
CDecisionForest	Class representing a decision forest
CDecisionForestEvaluator	Utility class for evaluating a decision forests
CDecisionForestTrainer	Trainer for decision trees
CDecisionTree	Class representing a decision tree
CDecisionTreeTrainerDataProvider
CDecisionTreeEvaluator	Utility class for evaluating a decision tree
CDecisionTreeTrainer	Trainer for decision trees
CFeatureHandler	Utility class interface which is used for creating and evaluating features
CFern	Class representing a Fern
CFernEvaluator	Utility class for evaluating a fern
CFernTrainer	Trainer for a Fern
CKmeans	K-means clustering
CMultiChannel2DComparisonFeature	Feature for comparing two sample points in 2D multi-channel data
CMultiChannel2DComparisonFeatureHandler	Feature utility class that handles the creation and evaluation of RGBD comparison features
CScaledMultiChannel2DComparisonFeatureHandler	Feature utility class that handles the creation and evaluation of RGBD comparison features
CScaledMultiChannel2DComparisonFeatureHandlerCCodeGenerator
CMultiChannel2DData	Holds two-dimensional multi-channel data
CMultiChannel2DDataSet	Holds a set of two-dimensional multi-channel data
CMultipleData2DExampleIndex	Example index for a set of 2D data blocks
CPairwisePotential
►CPermutohedral	Implementation of a high-dimensional gaussian filtering using the permutohedral lattice
CNeighbors
CHashTableOLD
CPointXY32f	2D point with float x- and y-coordinates
CPointXY32i	2D point with integer x- and y-coordinates
CRegressionVarianceNode	Node for a regression trees which optimizes variance
CRegressionVarianceStatsEstimator	Statistics estimator for regression trees which optimizes variance
CStatsEstimator	Class interface for gathering statistics for decision tree learning
CSVMParam	The structure stores the parameters for the classificationa nd must be initialized and passed to the training method pcl::SVMTrain
CSVMModel	The structure initialize a model created by the SVM (Support Vector Machines) classifier (pcl::SVMTrain)
CSVMDataPoint	The structure initialize a single feature value for the classification using SVM (Support Vector Machines)
CSVMData	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)
CSVM	Base class for SVM SVM (Support Vector Machines)
CSVMTrain	SVM (Support Vector Machines) training class for the SVM machine learning
CSVMClassify	SVM (Support Vector Machines) classification of a dataset
CCorrespondenceGrouping	Abstract base class for Correspondence Grouping algorithms
CGeometricConsistencyGrouping	Class implementing a 3D correspondence grouping enforcing geometric consistency among feature correspondences
CHough3DGrouping	Class implementing a 3D correspondence grouping algorithm that can deal with multiple instances of a model template found into a given scene
►CColorGradientDOTModality
CCandidate
►CColorGradientModality	Modality based on max-RGB gradients
CCandidate	Candidate for a feature (used in feature extraction methods)
►CColorModality
CCandidate
CCRHAlignment	CRHAlignment uses two Camera Roll Histograms (CRH) to find the roll rotation that aligns both views
CDenseQuantizedSingleModTemplate
CDenseQuantizedMultiModTemplate
CDistanceMap	Represents a distance map obtained from a distance transformation
CDOTModality
CDOTMODDetection
CDOTMOD	Template matching using the DOTMOD approach
CRFFaceDetectorTrainer
CGreedyVerification	A greedy hypothesis verification method
CGlobalHypothesesVerification	A hypothesis verification method proposed in "A Global Hypotheses Verification Method for 3D Object Recognition", A
CPapazovHV	A hypothesis verification method proposed in "An Efficient RANSAC for 3D Object Recognition in Noisy and Occluded Scenes", C
CHypothesisVerification	Abstract class for hypotheses verification methods
CISMPeak	This struct is used for storing peak
CBoundingBoxXYZ
►CLineRGBD	High-level class for template matching using the LINEMOD approach based on RGB and Depth data
CDetection	A LineRGBD detection
CEnergyMaps	Stores a set of energy maps
CLinearizedMaps	Stores a set of linearized maps
CLINEMODDetection	Represents a detection of a template using the LINEMOD approach
CLINEMOD	Template matching using the LINEMOD approach
CMaskMap
CGradientXY	A point structure representing Euclidean xyz coordinates, and the intensity value
CQuantizableModality	Interface for a quantizable modality
CQuantizedMap
CRegionXY	Defines a region in XY-space
CQuantizedMultiModFeature	Feature that defines a position and quantized value in a specific modality
CSparseQuantizedMultiModTemplate	A multi-modality template constructed from a set of quantized multi-modality features
CLINEMOD_OrientationMap	Map that stores orientations
CQuantizedNormalLookUpTable	Look-up-table for fast surface normal quantization
►CSurfaceNormalModality	Modality based on surface normals
CCandidate	Candidate for a feature (used in feature extraction methods)
CSolverDidntConvergeException	An exception that is thrown when the non linear solver didn't converge
CNotEnoughPointsException	An exception that is thrown when the number of correspondents is not equal to the minimum required
►CGeneralizedIterativeClosestPoint	GeneralizedIterativeClosestPoint is an ICP variant that implements the generalized iterative closest point algorithm as described by Alex Segal et al
COptimizationFunctorWithIndices	Optimization functor structure
►CGeneralizedIterativeClosestPoint6D	GeneralizedIterativeClosestPoint6D integrates L*a*b* color space information into the Generalized Iterative Closest Point (GICP) algorithm
CMyPointRepresentation	Custom point representation to perform kdtree searches in more than 3 (i.e
CGraphRegistration	GraphRegistration class is the base class for graph-based registration methods
►CSampleConsensusInitialAlignment	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
CErrorFunctor
CHuberPenalty
CTruncatedError
CIterativeClosestPoint	IterativeClosestPoint provides a base implementation of the Iterative Closest Point algorithm
CIterativeClosestPointWithNormals	IterativeClosestPointWithNormals is a special case of IterativeClosestPoint, that uses a transformation estimated based on Point to Plane distances by default
CIterativeClosestPointNonLinear	IterativeClosestPointNonLinear is an ICP variant that uses Levenberg-Marquardt optimization backend
CJointIterativeClosestPoint	JointIterativeClosestPoint extends ICP to multiple frames which share the same transform
CNormalDistributionsTransform	A 3D Normal Distribution Transform registration implementation for point cloud data
CNormalDistributionsTransform2D	NormalDistributionsTransform2D provides an implementation of the Normal Distributions Transform algorithm for scan matching
CPairwiseGraphRegistration	PairwiseGraphRegistration class aligns the clouds two by two
►CPPFHashMapSearch
CHashKeyStruct	Data structure to hold the information for the key in the feature hash map of the PPFHashMapSearch class
►CPPFRegistration	Class that registers two point clouds based on their sets of PPFSignatures
CPoseWithVotes	Structure for storing a pose (represented as an Eigen::Affine3f) and an integer for counting votes
CPyramidFeatureHistogram	Class that compares two sets of features by using a multiscale representation of the features inside a pyramid
CRegistration	Registration represents the base registration class for general purpose, ICP-like methods
CSampleConsensusPrerejective	Pose estimation and alignment class using a prerejective RANSAC routine
CLeastMedianSquares	LeastMedianSquares represents an implementation of the LMedS (Least Median of Squares) algorithm
CMaximumLikelihoodSampleConsensus	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
CMEstimatorSampleConsensus	MEstimatorSampleConsensus represents an implementation of the MSAC (M-estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S
CProgressiveSampleConsensus	ProgressiveSampleConsensus represents an implementation of the PROSAC (PROgressive SAmple Consensus) algorithm, as described in: "Matching with PROSAC – Progressive Sample Consensus", Chum, O
CRandomSampleConsensus	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
CRandomizedMEstimatorSampleConsensus	RandomizedMEstimatorSampleConsensus represents an implementation of the RMSAC (Randomized M-estimator SAmple Consensus) algorithm, which basically adds a Td,d test (see RandomizedRandomSampleConsensus) to an MSAC estimator (see MEstimatorSampleConsensus)
CRandomizedRandomSampleConsensus	RandomizedRandomSampleConsensus represents an implementation of the RRANSAC (Randomized RANdom SAmple Consensus), as described in "Randomized RANSAC with Td,d test", O
CSampleConsensus	SampleConsensus represents the base class
CSampleConsensusModel	SampleConsensusModel represents the base model class
CSampleConsensusModelFromNormals	SampleConsensusModelFromNormals represents the base model class for models that require the use of surface normals for estimation
CFunctor	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) depending on the chosen _Scalar
CSampleConsensusModelCircle2D	SampleConsensusModelCircle2D defines a model for 2D circle segmentation on the X-Y plane
CSampleConsensusModelCircle3D	SampleConsensusModelCircle3D defines a model for 3D circle segmentation
CSampleConsensusModelCone	SampleConsensusModelCone defines a model for 3D cone segmentation
CSampleConsensusModelCylinder	SampleConsensusModelCylinder defines a model for 3D cylinder segmentation
CSampleConsensusModelEllipse3D	SampleConsensusModelEllipse3D defines a model for 3D ellipse segmentation
CSampleConsensusModelLine	SampleConsensusModelLine defines a model for 3D line segmentation
CSampleConsensusModelNormalParallelPlane	SampleConsensusModelNormalParallelPlane defines a model for 3D plane segmentation using additional surface normal constraints
CSampleConsensusModelNormalPlane	SampleConsensusModelNormalPlane defines a model for 3D plane segmentation using additional surface normal constraints
CSampleConsensusModelNormalSphere	SampleConsensusModelNormalSphere defines a model for 3D sphere segmentation using additional surface normal constraints
CSampleConsensusModelParallelLine	SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular constraints
CSampleConsensusModelParallelPlane	SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional angular constraints
CSampleConsensusModelPerpendicularPlane	SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional angular constraints
CSampleConsensusModelPlane	SampleConsensusModelPlane defines a model for 3D plane segmentation
CSampleConsensusModelRegistration	SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection
CSampleConsensusModelRegistration2D	SampleConsensusModelRegistration2D defines a model for Point-To-Point registration outlier rejection using distances between 2D pixels
CSampleConsensusModelSphere	SampleConsensusModelSphere defines a model for 3D sphere segmentation
CSampleConsensusModelStick	SampleConsensusModelStick defines a model for 3D stick segmentation
CSampleConsensusModelTorus	SampleConsensusModelTorus defines a model for 3D torus segmentation
CApproximateProgressiveMorphologicalFilter	Implements the Progressive Morphological Filter for segmentation of ground points
CComparator	Comparator is the base class for comparators that compare two points given some function
CConditionalEuclideanClustering	ConditionalEuclideanClustering performs segmentation based on Euclidean distance and a user-defined clustering condition
CCPCSegmentation	A segmentation algorithm partitioning a supervoxel graph
CCrfNormalSegmentation
CCrfSegmentation
CEdgeAwarePlaneComparator	EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
CEuclideanClusterComparator	EuclideanClusterComparator is a comparator used for finding clusters based on euclidean distance
CEuclideanPlaneCoefficientComparator	EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
CEuclideanClusterExtraction	EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense
CLabeledEuclideanClusterExtraction	LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info
CExtractPolygonalPrismData	ExtractPolygonalPrismData uses a set of point indices that represent a planar model, and together with a given height, generates a 3D polygonal prism
►CGrabCut	Implementation of the GrabCut segmentation in "GrabCut — Interactive Foreground Extraction using Iterated Graph Cuts" by Carsten Rother, Vladimir Kolmogorov and Andrew Blake
CNLinks
CGroundPlaneComparator	GroundPlaneComparator is a Comparator for detecting smooth surfaces suitable for driving
CLCCPSegmentation	A simple segmentation algorithm partitioning a supervoxel graph into groups of locally convex connected supervoxels separated by concave borders
CMinCutSegmentation	This class implements the segmentation algorithm based on minimal cut of the graph
COrganizedConnectedComponentSegmentation	OrganizedConnectedComponentSegmentation allows connected components to be found within organized point cloud data, given a comparison function
COrganizedMultiPlaneSegmentation	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
CPlanarPolygonFusion	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
CPlanarRegion	PlanarRegion represents a set of points that lie in a plane
CPlaneCoefficientComparator	PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
CPlaneRefinementComparator	PlaneRefinementComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
CProgressiveMorphologicalFilter	Implements the Progressive Morphological Filter for segmentation of ground points
CRegion3D	Region3D represents summary statistics of a 3D collection of points
CRegionGrowing	Implements the well known Region Growing algorithm used for segmentation
CRegionGrowingRGB	Implements the well known Region Growing algorithm used for segmentation based on color of points
CRGBPlaneCoefficientComparator	RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
CSACSegmentation	SACSegmentation represents the Nodelet segmentation class for Sample Consensus methods and models, in the sense that it just creates a Nodelet wrapper for generic-purpose SAC-based segmentation
CSACSegmentationFromNormals	SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and models that require the use of surface normals for estimation
CSeededHueSegmentation	SeededHueSegmentation
CSegmentDifferences	SegmentDifferences obtains the difference between two spatially aligned point clouds and returns the difference between them for a maximum given distance threshold
CSupervoxel	Supervoxel container class - stores a cluster extracted using supervoxel clustering
►CSupervoxelClustering	Implements a supervoxel algorithm based on voxel structure, normals, and rgb values
CVoxelData	VoxelData is a structure used for storing data within a pcl::octree::OctreePointCloudAdjacencyContainer
CUnaryClassifier
CDigitalElevationMapBuilder	Build a Digital Elevation Map in the column-disparity space from a disparity map and a color image of the scene
CDisparityMapConverter	Compute point cloud from the disparity map
CStereoGrabberBase	Base class for Stereo file grabber
CStereoGrabber
CStereoMatching	Stereo Matching abstract class
CGrayStereoMatching	Stereo Matching abstract class for Grayscale images
CBlockBasedStereoMatching	Block based (or fixed window) Stereo Matching class
CAdaptiveCostSOStereoMatching	Adaptive Cost 2-pass Scanline Optimization Stereo Matching class
CBilateralUpsampling	Bilateral filtering implementation, based on the following paper:
CConcaveHull	ConcaveHull (alpha shapes) using libqhull library
CConvexHull	ConvexHull using libqhull library
CEarClipping	The ear clipping triangulation algorithm
CGreedyProjectionTriangulation	GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points based on local 2D projections
►CGridProjection	Grid projection surface reconstruction method
CLeaf	Data leaf
CMarchingCubes	The marching cubes surface reconstruction algorithm
CMarchingCubesHoppe	The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance from tangent planes, proposed by Hoppe et
CMarchingCubesRBF	The marching cubes surface reconstruction algorithm, using a signed distance function based on radial basis functions
►CMLSResult	Data structure used to store the results of the MLS fitting
CMLSProjectionResults	Data structure used to store the MLS projection results
CPolynomialPartialDerivative	Data structure used to store the MLS polynomial partial derivatives
►CMovingLeastSquares	MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm for data smoothing and improved normal estimation
►CMLSVoxelGrid	A minimalistic implementation of a voxel grid, necessary for the point cloud upsampling
CLeaf
COrganizedFastMesh	Simple triangulation/surface reconstruction for organized point clouds
CPoisson	The Poisson surface reconstruction algorithm
CCloudSurfaceProcessing	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
CMeshProcessing	MeshProcessing represents the base class for mesh processing algorithms
CPCLSurfaceBase	Pure abstract class
CSurfaceReconstruction	SurfaceReconstruction represents a base surface reconstruction class
CMeshConstruction	MeshConstruction represents a base surface reconstruction class
CSurfelSmoothing
CTextureMapping	The texture mapping algorithm
CMeshQuadricDecimationVTK	PCL mesh decimation based on vtkQuadricDecimation from the VTK library
CMeshSmoothingLaplacianVTK	PCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library
CMeshSmoothingWindowedSincVTK	PCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library
CMeshSubdivisionVTK	PCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library
CVTKUtils
CRegistrationVisualizer	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
CvtkXRenderWindowInteractor
►Npcl_cuda
CFilter	Removes points with x, y, or z equal to NaN
CisFiniteAOS	Check if a specific point is valid or not
CisFiniteSOA	Check if a specific point is valid or not
CisFiniteZIPSOA	Check if a specific point is valid or not
CPassThrough	PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints
CPassThrough< PointCloudAOS< Device > >
CPassThrough< PointCloudSOA< Device > >
CVoxelGrid	VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
CVoxelGrid< PointCloudAOS< Device > >
CVoxelGrid< PointCloudSOA< Device > >
CMEstimatorSampleConsensus
NUi