Loading...
Searching...
No Matches
Namespace List
Here is a list of all namespaces with brief descriptions:

BFGSSpace |
boost |
detail |
is_random_access< eigen_listS > |
is_random_access< eigen_vecS > |
container_gen< eigen_listS, ValueType > |
container_gen< eigen_vecS, ValueType > |
eigen_listS |
eigen_vecS |
parallel_edge_traits< eigen_listS > |
parallel_edge_traits< eigen_vecS > |
Eigen |
NumTraits< pcl::ndt2d::NormalDist< PointT > > |
PolynomialSolver< _Scalar, 2 > |
flann |
Index |
L2 |
L2_Simple |
Matrix |
NNIndex |
Loki |
TL |
TypeAt |
TypeAt< Typelist< Head, Tail >, 0 > |
TypeAt< Typelist< Head, Tail >, i > |
Int2Type |
NullType |
Typelist |
NcvCTprep | Compile-time assert namespace
assertTest |
CT_ASSERT_FAILURE |
CT_ASSERT_FAILURE< true > |
NCVRuntimeTemplateBool |
KernelCaller |
KernelCaller< TList, 0, Func > |
openni |
openni_wrapper |
DepthImage | This class provides methods to fill a depth or disparity image
DeviceKinect | Concrete implementation of the interface OpenNIDevice for a MS Kinect device
DeviceONI | Concrete implementation of the interface OpenNIDevice for a virtual device playing back an ONI file
DevicePrimesense | Concrete implementation of the interface OpenNIDevice for a Primesense device
DeviceXtionPro | Concrete implementation of the interface OpenNIDevice for a Asus Xtion Pro device
Image | Image class containing just a reference to image meta data
ImageBayerGRBG | This class provides methods to fill a RGB or Grayscale image buffer from underlying Bayer pattern image
ImageRGB24 | This class provides methods to fill a RGB or Grayscale image buffer from underlying RGB24 image
ImageYUV422 | Concrete implementation of the interface Image for a YUV 422 image used by Primesense devices
IRImage | Class containing just a reference to IR meta data
OpenNIDevice | Class representing an astract device for OpenNI devices: Primesense PSDK, Microsoft Kinect, Asus Xtion Pro/Live
ShiftConversion |
OpenNIDriver | Driver class implemented as Singleton
DeviceContext |
OpenNIException | General exception class
ShiftToDepthConverter | This class provides conversion of the openni 11-bit shift data to depth;
pcl |
common |
internal |
CloudGenerator |
CloudGenerator< pcl::PointXY, GeneratorT > |
IntensityFieldAccessor |
IntensityFieldAccessor< pcl::InterestPoint > |
IntensityFieldAccessor< pcl::PointNormal > |
IntensityFieldAccessor< pcl::PointSurfel > |
IntensityFieldAccessor< pcl::PointWithRange > |
IntensityFieldAccessor< pcl::PointWithScale > |
IntensityFieldAccessor< pcl::PointWithViewpoint > |
IntensityFieldAccessor< pcl::PointXYZ > |
IntensityFieldAccessor< pcl::PointXYZHSV > |
IntensityFieldAccessor< pcl::PointXYZL > |
IntensityFieldAccessor< pcl::PointXYZLAB > |
IntensityFieldAccessor< pcl::PointXYZLNormal > |
IntensityFieldAccessor< pcl::PointXYZRGB > |
IntensityFieldAccessor< pcl::PointXYZRGBA > |
IntensityFieldAccessor< pcl::PointXYZRGBL > |
IntensityFieldAccessor< pcl::PointXYZRGBNormal > |
normal_distribution | Normal distribution
NormalGenerator | NormalGenerator class generates a random number from a normal distribution specified by (mean, sigma)
Parameters |
uniform_distribution | Uniform distribution dummy struct
uniform_distribution< T, std::enable_if_t< std::is_floating_point< T >::value > > | Uniform distribution float specialized
uniform_distribution< T, std::enable_if_t< std::is_integral< T >::value > > | Uniform distribution int specialized
UniformGenerator | 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
Parameters |
ComparisonOps |
console |
TicToc |
cuda |
detail |
DjSets |
Graph |
GraphEdge |
SegmLink |
SegmLinkVal |
AddCovariances | Adds two matrices element-wise
AddPoints | Simple kernel to add two points
ChangeColor |
CheckPlanarInlier | Check if a certain tuple is a point inlier
CheckPlanarInlierIndices | Check if a certain tuple is a point inlier
CheckPlanarInlierKinectIndices | Check if a certain tuple is a point inlier
CheckPlanarInlierKinectNormalIndices | Check if a certain tuple is a point inlier
CheckPlanarInlierNormalIndices | Check if a certain tuple is a point inlier
ComputeCovarianceForPoint | Kernel to compute a `‘covariance matrix’' for a single point
ComputeXYZ | Compute the XYZ values for a point based on disparity information
ComputeXYZRGB | Compute the XYZ and RGB values for a point based on disparity information
convert_point_to_float3 | Simple kernel to convert a PointXYZRGB to float3
CountPlanarInlier | Check if a certain tuple is a point inlier
CovarianceMatrix | Misnamed class holding a 3x3 matrix
Create1PointPlaneHypothesis | Check if a certain tuple is a point inlier
Create1PointPlaneSampleHypothesis | Check if a certain tuple is a point inlier
CreatePlaneHypothesis | Check if a certain tuple is a point inlier
DebayerBilinear |
Debayering |
DebayeringDownsampling |
DeleteIndices | Check if a certain tuple is a point inlier
Device | Device helper class
DisparityBoundSmoothing |
DisparityClampedSmoothing |
DisparityHelperMap |
DisparityToCloud | Disparity to PointCloudAOS generator
downsampleIndices |
FastNormalEstimationKernel |
Host | Host helper class
isInlier | Check if a certain tuple is a point inlier
isNaNPoint |
isNotInlier |
isNotZero |
MultiRandomSampleConsensus | RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography", Martin A
NewCheckPlanarInlier | Check if a certain tuple is a point inlier
NormalDeviationKernel |
NormalEstimationKernel |
OpenNIRGB | Simple structure holding RGB data
OrganizedRadiusSearch | Kernel to compute a radius neighborhood given a organized point cloud (aka range image cloud)
parallel_random_generator |
PCLCUDABase | PCL base class
PointCloudAOS | PointCloudAOS represents an AOS (Array of Structs) PointCloud implementation for CUDA processing
PointCloudSOA | PointCloudSOA represents a SOA (Struct of Arrays) PointCloud implementation for CUDA processing
PointIterator |
PointIterator< Device, T > |
PointIterator< Host, T > |
PointXYZRGB | Default point xyz-rgb structure
RandomSampleConsensus | RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography", Martin A
RGB | Default RGB structure, defined as a union over 4 chars
SampleConsensus |
SampleConsensusModel | SampleConsensusModel represents the base model class
SampleConsensusModel1PointPlane | SampleConsensusModel1PointPlane defines a model for 3D plane segmentation
SampleConsensusModelPlane | SampleConsensusModelPlane defines a model for 3D plane segmentation
ScopeTimeCPU | Class to measure the time spent in a scope
ScopeTimeGPU | Class to measure the time spent in a scope
SetColor |
StorageAllocator |
StorageAllocator< Device, T > |
StorageAllocator< Host, T > |
StoragePointer |
StoragePointer< Device, T > |
StoragePointer< Host, T > |
YUV2RGB |
YUV2RGBKernel |
deprecated |
T |
detail |
traits |
descriptorSize |
descriptorSize< BRISKSignature512 > |
descriptorSize< ESFSignature640 > |
descriptorSize< FPFHSignature33 > |
descriptorSize< GASDSignature512 > |
descriptorSize< GASDSignature7992 > |
descriptorSize< GASDSignature984 > |
descriptorSize< GFPFHSignature16 > |
descriptorSize< GRSDSignature21 > |
descriptorSize< Histogram< N > > |
descriptorSize< Narf36 > |
descriptorSize< PFHRGBSignature250 > |
descriptorSize< PFHSignature125 > |
descriptorSize< ShapeContext1980 > |
descriptorSize< SHOT1344 > |
descriptorSize< SHOT352 > |
descriptorSize< UniqueShapeContext1960 > |
descriptorSize< VFHSignature308 > |
AccumulatorCurvature |
AccumulatorIntensity |
AccumulatorLabel |
AccumulatorNormal |
AccumulatorRGBA |
Accumulators |
AccumulatorXYZ |
AddPoint |
compat_with_flann |
compat_with_flann< std::size_t > |
CopyPointHelper |

CopyPointHelper< 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 > >

CopyPointHelper< 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 > >

CopyPointHelper< PointInT, PointOutT, std::enable_if_t< std::is_same< PointInT, PointOutT >::value > > |
EigenVector |
FieldAdder |
FieldAdderAdvanced | Used together with `pcl::for_each_type`, creates list of all fields, and list of size of each field
FieldCaster |
FieldCopier | Used together with `pcl::for_each_type`, copies all point fields from `cloud_data` (respecting each field offset) to `msg_data` (tightly packed)
FieldMapper |
FieldMapping |
GetPoint |
int_type | Int_type::type refers to an integral type that satisfies template parameters
int_type< 16, false > |
int_type< 16, true > |
int_type< 32, false > |
int_type< 32, true > |
int_type< 64, false > |
int_type< 64, true > |
int_type< 8, false > |
int_type< 8, true > |
IsAccumulatorCompatible |
apply |
MeshIndex |
Transformer | A helper struct to apply an SO3 or SE3 transform to a 3D point
device |
kinfuLS |
Block |
Eigen33 |
MiniMat |
Emulation |
float12 |
float8 |
Intr | Camera intrinsics structure
LightSource | Light source collection
Mat33 | 3x3 Matrix for device code
Warp |
bit_not |
Block |
CalcMorton |
CompareByLevelCode |
ConnectedComponents |
CUDATree | Struct that holds a single RDF tree in GPU
Dilatation |
Eigen33 |
MiniMat |
Emulation |
FacetStream |
float12 |
float8 |
Histogram |
InitalSimplex |
Intr | Camera intrinsics structure
LessThanByFacet |
LightSource | Light source collection
Mat33 | 3x3 Matrix for device code
Morton |
MultiTreeLiveProc | Processor using multiple trees
NonCachedLoad |
OctreeGlobal |
OctreeGlobalWithBox |
OctreeImpl |
OctreeDataHost |
OctreeIteratorDevice |
OctreeIteratorDeviceNS |
OctreePriorityIteratorDevice |
plusWeighted |
PointStream |
PPFRGBSignature |
PPFSignature |
PrincipalCurvatures |
prob_histogram |
ProbabilityProc | Implementation Class to process probability histograms on GPU
VFHEstimationImpl |
Warp |
distances |
experimental |
advanced |
FunctorFilter | Filter point clouds and indices based on a function object passed in the ctor
face_detection |
FaceDetectorDataProvider |
FeatureHandlerDepthAverage |
FeatureType |
PoseClassRegressionVarianceStatsEstimator | Statistics estimator for regression trees which optimizes information gain and pose parameters error
RFTreeNode |
TrainingExample |
features |
ISMModel | The assignment of this structure is to store the statistical/learned weights and other information of the trained Implicit Shape Model algorithm
ISMVoteList | This class is used for storing, analyzing and manipulating votes obtained from ISM algorithm
fields |
filters |
Convolution | Convolution is a mathematical operation on two functions f and g, producing a third function that is typically viewed as a modified version of one of the original functions
Convolution3D | Convolution3D handles the non organized case where width and height are unknown or if you are only interested in convolving based on local neighborhood information
ConvolvingKernel | Class ConvolvingKernel base class for all convolving kernels
ConvolvingKernel< PointT, pcl::Normal > |
ConvolvingKernel< PointT, pcl::PointXY > |
GaussianKernel | Gaussian kernel implementation interface Use this as implementation reference
GaussianKernelRGB | Gaussian kernel implementation interface with RGB channel handling Use this as implementation reference
Pyramid | Pyramid constructs a multi-scale representation of an organised point cloud
geometry |
DefaultMeshTraits | The mesh traits are used to set up compile time settings for the mesh
FaceAroundFaceCirculator | Circulates clockwise around a face and returns an index to the face of the outer half-edge (the target)
FaceAroundVertexCirculator | Circulates counter-clockwise around a vertex and returns an index to the face of the outgoing half-edge (the target)
IncomingHalfEdgeAroundVertexCirculator | Circulates counter-clockwise around a vertex and returns an index to the incoming half-edge (the target)
InnerHalfEdgeAroundFaceCirculator | Circulates clockwise around a face and returns an index to the inner half-edge (the target)
MeshBase | Base class for the half-edge mesh
MeshIO | Read / write the half-edge mesh from / to a file
NoData | No data is associated with the vertices / half-edges / edges / faces
OuterHalfEdgeAroundFaceCirculator | Circulates clockwise around a face and returns an index to the outer half-edge (the target)
OutgoingHalfEdgeAroundVertexCirculator | Circulates counter-clockwise around a vertex and returns an index to the outgoing half-edge (the target)
PolygonMesh | General half-edge mesh that can store any polygon with a minimum number of vertices of 3
PolygonMeshTag | Tag describing the type of the mesh
QuadMesh | Half-edge mesh that can only store quads
QuadMeshTag | Tag describing the type of the mesh
TriangleMesh | Half-edge mesh that can only store triangles
TriangleMeshTag | Tag describing the type of the mesh
Vertex | A vertex is a node in the mesh
VertexAroundFaceCirculator | Circulates clockwise around a face and returns an index to the terminating vertex of the inner half-edge (the target)
VertexAroundVertexCirculator | Circulates counter-clockwise around a vertex and returns an index to the terminating vertex of the outgoing half-edge (the target)
gpu |
kinfuLS |
CaptureOpenNI |
ColorVolume | ColorVolume class
CyclicalBuffer | CyclicalBuffer implements a cyclical TSDF buffer
KinfuTracker | KinfuTracker class encapsulates implementation of Microsoft Kinect Fusion algorithm
MarchingCubes | MarchingCubes implements MarchingCubes functionality for TSDF volume on GPU
PixelRGB | Input/output pixel format for KinfuTracker
RayCaster | Class that performs raycasting for TSDF volume
StandaloneMarchingCubes | The Standalone Marching Cubes Class provides encapsulated functionality for the Marching Cubes implementation originally by Anatoly Baksheev
tsdf_buffer | Structure to handle buffer addresses
TsdfVolume | TsdfVolume class
Header | Structure storing voxel grid resolution, volume size (in mm) and element_size of data stored on host
people |
label_skeleton |
trees |
AttribLocation |
Histogram |
HistogramPair |
LabeledAttrib |
LabeledFeature |
Node |
SplitPoint |
Blob2 | This structure contains all parameters to describe blobs and their parent/child relations
FaceDetector |
OrganizedPlaneDetector |
PeopleDetector |
PersonAttribs |
ProbabilityProcessor |
RDFBodyPartsDetector |
Tree2 | This structure contains all parameters to describe the segmented tree
AsyncCopy |
CaptureOpenNI |
ColorVolume | ColorVolume class
DataSource |
Normal2PointXYZ |
DeviceArray | DeviceArray class
DeviceArray2D | DeviceArray2D class
DeviceMemory | DeviceMemory class
DeviceMemory2D | DeviceMemory2D class
DevPtr |
EuclideanClusterExtraction | EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, depending on pcl::gpu::octree
EuclideanLabeledClusterExtraction | EuclideanLabeledClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, depending on pcl::gpu::octree
Feature | Feature represents the base feature class
FeatureFromNormals | Feature represents the base feature class that takes normals as input also
FPFHEstimation | Class for FPFH estimation
KinfuTracker | KinfuTracker class encapsulates implementation of Microsoft Kinect Fusion algorithm
MarchingCubes | MarchingCubes implements MarchingCubes functionality for TSDF volume on GPU
NeighborIndices |
NormalEstimation | Class for normal estimation
Octree | Octree implementation on GPU
ParticleFilterGPUTracker |
PFHEstimation | Class for PFH estimation
PFHRGBEstimation | Class for PFHRGB estimation
PixelRGB | Input/output pixel format for KinfuTracker
PPFEstimation | **
PPFRGBEstimation | **
PPFRGBRegionEstimation | **
PrincipalCurvaturesEstimation | ‍**
PseudoConvexHull3D |
PtrStep |
PtrStepSz |
PtrSz |
RayCaster | Class that performs raycasting for TSDF volume
ScopeTimer |
SeededHueSegmentation |
SpinImageEstimation | ‍**
TextureBinder |
Timer |
TsdfVolume | TsdfVolume class
VFHEstimation | **
internal |
cloud_point_index_idx | Used internally in voxel grid classes
io |
depth_sense |
DepthSenseDeviceManager | A helper class for enumerating and managing access to DepthSense devices
DepthSenseGrabberImpl |
openni2 |
OpenNI2Device |
OpenNI2DeviceInfo |
OpenNI2DeviceManager |
OpenNI2FrameListener |
OpenNI2TimerFilter |
OpenNI2VideoMode |
ply |
io_operators |
ply_parser | Class ply_parser parses a PLY file and generates appropriate atomic parsers for the body
list_property_begin_callback_type |
list_property_definition_callback_type |
list_property_definition_callbacks_type |
list_property_element_callback_type |
list_property_end_callback_type |
scalar_property_callback_type |
scalar_property_definition_callback_type |
scalar_property_definition_callbacks_type |
type_traits |
real_sense |
RealSenseDevice |
RealSenseDeviceManager |
AverageBuffer | A buffer that computes running window average of the data inserted
Buffer | An abstract base class for fixed-size data buffers
CameraParameters | Basic camera parameters placeholder
CompressionPointTraits |
CompressionPointTraits< PointXYZRGB > |
CompressionPointTraits< PointXYZRGBA > |
configurationProfile_t |
DeBayer | Various debayering methods
DepthImage | This class provides methods to fill a depth or disparity image
FrameWrapper | Pure abstract interface to wrap native frame data types
Image | Image interface class providing an interface to fill a RGB or Grayscale image buffer
ImageRGB24 | This class provides methods to fill a RGB or Grayscale image buffer from underlying RGB24 image
ImageYUV422 | Concrete implementation of the interface Image for a YUV 422 image used by Primesense devices
IOException | General IO exception class
IRImage | Class containing just a reference to IR meta data
LZFBayer8ImageReader | PCL-LZF 8-bit Bayer image format reader
LZFBayer8ImageWriter | PCL-LZF 8-bit Bayer image format writer
LZFDepth16ImageReader | PCL-LZF 16-bit depth image format reader
LZFDepth16ImageWriter | PCL-LZF 16-bit depth image format writer
LZFImageReader | PCL-LZF image format reader
LZFImageWriter | PCL-LZF image format writer
LZFRGB24ImageReader | PCL-LZF 24-bit RGB image format reader
LZFRGB24ImageWriter | PCL-LZF 24-bit RGB image format writer
LZFYUV422ImageReader | PCL-LZF 8-bit Bayer image format reader
LZFYUV422ImageWriter | PCL-LZF 16-bit YUV422 image format writer
MedianBuffer | A buffer that computes running window median of the data inserted
OctreePointCloudCompression | Octree pointcloud compression class
OrganizedConversion |
OrganizedConversion< PointT, false > |
OrganizedConversion< PointT, true > |
OrganizedPointCloudCompression |
PointCloudImageExtractor | Base Image Extractor class for organized point clouds
PointCloudImageExtractorFromCurvatureField | Image Extractor which uses the data present in the "curvature" field to produce a curvature map (as a monochrome image with mono16 encoding)
PointCloudImageExtractorFromIntensityField | Image Extractor which uses the data present in the "intensity" field to produce a monochrome intensity image (with mono16 encoding)
PointCloudImageExtractorFromLabelField | Image Extractor which uses the data present in the "label" field to produce either monochrome or RGB image where different labels correspond to different colors
PointCloudImageExtractorFromNormalField | Image Extractor which uses the data present in the "normal" field
PointCloudImageExtractorFromRGBField | Image Extractor which uses the data present in the "rgb" or "rgba" fields to produce a color image with rgb8 encoding
PointCloudImageExtractorFromZField | Image Extractor which uses the data present in the "z" field to produce a depth map (as a monochrome image with mono16 encoding)
PointCloudImageExtractorWithScaling | Image Extractor extension which provides functionality to apply scaling to the values extracted from a field
SingleBuffer | A simple buffer that only stores data
TARHeader | A TAR file's header, as described on https://en.wikipedia.org/wiki/Tar_%28file_format%29
ism |
ImplicitShapeModelEstimation | This class implements Implicit Shape Model algorithm described in "Hough Transforms and 3D SURF for robust three dimensional classification" by Jan Knopp, Mukta Prasad, Geert Willems, Radu Timofte, and Luc Van Gool
LocationInfo | This structure stores the information about the keypoint
TermCriteria | This structure is used for determining the end of the k-means clustering process
VisualWordStat | Structure for storing the visual word
keypoints |
agast |
AbstractAgastDetector | Abstract detector class for AGAST corner point detectors
CompareScoreIndex | Score index comparator
ScoreIndex | Structure holding an index and the associated keypoint score
AgastDetector5_8 | Detector class for AGAST corner point detector (5_8)
AgastDetector7_12s | Detector class for AGAST corner point detector (7_12s)
OastDetector9_16 | Detector class for AGAST corner point detector (OAST 9_16)
brisk |
internal |
kinfuLS |
ScreenshotManager | Screenshot Manager saves a screenshot with the corresponding camera pose from Kinfu
WorldModel | WorldModel maintains a 3D point cloud that can be queried and updated via helper functions
ndt2d |
NDT2D | Build a Normal Distributions Transform of a 2D point cloud
NDTSingleGrid | Build a set of normal distributions modelling a 2D point cloud, and provide the value and derivatives of the model at any point via the test (...) function
NormalDist | A normal distribution estimation class
ValueAndDerivatives | Class to store vector value and first and second derivatives (grad vector and hessian matrix), so they can be returned easily from functions
occlusion_reasoning |
ZBuffering | Class to reason about occlusions
octree |
BufferedBranchNode |
ColorCoding | ColorCoding class
IteratorState |
Octree2BufBase | Octree double buffer class
OctreeBase | Octree class
OctreeBranchNode | Abstract octree branch class
OctreeBreadthFirstIterator | Octree iterator class
OctreeContainerBase | Octree container class that can serve as a base to construct own leaf node container classes
OctreeContainerEmpty | Octree container class that does not store any information
OctreeContainerPointIndex | Octree container class that does store a single point index
OctreeContainerPointIndices | Octree container class that does store a vector of point indices
OctreeDepthFirstIterator | Octree iterator class
OctreeFixedDepthIterator | Octree iterator class
OctreeIteratorBase | Abstract octree iterator class
OctreeKey | Octree key class
OctreeLeafNode | Abstract octree leaf class
OctreeLeafNodeBreadthFirstIterator | Octree leaf node iterator class
OctreeLeafNodeDepthFirstIterator | Octree leaf node iterator class
OctreeNode | Abstract octree node class
OctreeNodePool | Octree node pool
OctreePointCloud | Octree pointcloud class
OctreePointCloudAdjacency | Octree pointcloud voxel class which maintains adjacency information for its voxels
OctreePointCloudAdjacencyContainer | Octree adjacency leaf container class- stores a list of pointers to neighbors, number of points added, and a DataT value
OctreePointCloudChangeDetector | Octree pointcloud change detector class
OctreePointCloudDensity | Octree pointcloud density class
OctreePointCloudDensityContainer | Octree pointcloud density leaf node class
OctreePointCloudOccupancy | Octree pointcloud occupancy class
OctreePointCloudPointVector | Octree pointcloud point vector class
OctreePointCloudSearch | Octree pointcloud search class
prioBranchQueueEntry | Priority queue entry for branch nodes
prioPointQueueEntry | Priority queue entry for point candidates
OctreePointCloudSinglePoint | Octree pointcloud single point class
OctreePointCloudVoxelCentroid | Octree pointcloud voxel centroid class
OctreePointCloudVoxelCentroidContainer | Octree pointcloud voxel centroid leaf node class
PointCoding | PointCoding class
outofcore |
OutofcoreAbstractMetadata |
OutofcoreAbstractNodeContainer |
OutofcoreBreadthFirstIterator |
OutofcoreDepthFirstIterator |
OutofcoreIteratorBase | Abstract octree iterator class
OutofcoreOctreeBase | This code defines the octree used for point storage at Urban Robotics
OutofcoreOctreeBaseMetadata | Encapsulated class to read JSON metadata into memory, and write the JSON metadata associated with the octree root node
OutofcoreOctreeBaseNode | OutofcoreOctreeBaseNode Class internally representing nodes of an outofcore octree, with accessors to its data via the pcl::outofcore::OutofcoreOctreeDiskContainer class or pcl::outofcore::OutofcoreOctreeRamContainer class, whichever it is templated against.
OutofcoreOctreeDiskContainer | Class responsible for serialization and deserialization of out of core point data
OutofcoreOctreeNodeMetadata | Encapsulated class to read JSON metadata into memory, and write the JSON metadata for each node
OutofcoreOctreeRamContainer | Storage container class which the outofcore octree base is templated against
OutofcoreParams |
people |
GroundBasedPeopleDetectionApp | GroundBasedPeopleDetectionApp performs people detection on RGB-D data having as input the ground plane coefficients
HeadBasedSubclustering | HeadBasedSubclustering represents a class for searching for people inside a HeightMap2D based on a 3D head detection algorithm
HeightMap2D | HeightMap2D represents a class for creating a 2D height map from a point cloud and searching for its local maxima
HOG | HOG represents a class for computing the HOG descriptor described in Dalal, N
PersonClassifier |
PersonCluster | PersonCluster represents a class for representing information about a cluster containing a person
poisson |
Allocator | This templated class assists in memory allocation and is well suited for instances when it is known that the sequence of memory allocations is performed in a stack-based manner, so that memory allocated last is released first
AllocatorState |
BinaryNode |
BSplineData |
BSplineComponents |
BSplineElementCoefficients |
BSplineElements |
CoredEdgeIndex |
CoredFileMeshData |
CoredFileMeshData2 |
CoredMeshData |
CoredMeshData2 |
Vertex |
CoredPointIndex |
CoredVectorMeshData |
CoredVectorMeshData2 |
CoredVertexIndex |
Cube |
Edge |
EdgeIndex |
FunctionData |
MapReduceVector |
MarchingCubes |
MarchingSquares |
MatrixEntry |
MinimalAreaTriangulation |
NVector |
OctNode |
ConstNeighborKey3 |
ConstNeighborKey5 |
ConstNeighbors3 |
ConstNeighbors5 |
NeighborKey3 |
NeighborKey5 |
Neighbors3 |
Neighbors5 |
Octree |
Point3D |
PoissonBadArgumentException | An exception that is thrown when the arguments number or type is wrong/unhandled
PoissonBadInitException | An exception that is thrown when initialization fails
PoissonException | A base class for all poisson exceptions which inherits from std::runtime_error
PoissonOpenMPException | An exception that is thrown when something goes wrong inside an openMP for loop
Polynomial |
PPolynomial |
RootInfo |
SortedTreeNodes |
CornerIndices |
CornerTableData |
EdgeIndices |
EdgeTableData |
SparseMatrix |
SparseSymmetricMatrix |
Square |
StartingPolynomial |
TreeNodeData |
Triangle |
TriangleIndex |
Triangulation |
TriangulationEdge |
TriangulationTriangle |
UpSampleData |
Vector |
VertexData |
recognition |
aux |
BVH | This class is an implementation of bounding volume hierarchies
BoundedObject |
Node |
HoughSpace3D | HoughSpace3D is a 3D voting space
Hypothesis |
HypothesisBase |
ModelLibrary |
Model | Stores some information about the model
ObjRecRANSAC | This is a RANSAC-based 3D object recognition method
HypothesisCreator |
OrientedPointPair |
Output | This is an output item of the ObjRecRANSAC::recognize() method
ORRGraph |
Node |
ORROctree | That's a very specialized and simple octree class
Node |
Data |
ORROctreeZProjection |
Pixel |
Set |
RigidTransformSpace |
RotationSpace | This is a class for a discrete representation of the rotation space based on the axis-angle representation
RotationSpaceCell |
Entry |
RotationSpaceCellCreator |
RotationSpaceCreator |
SimpleOctree |
Node |
TrimmedICP |
VoxelStructure | This class is a box in R3 built of voxels ordered in a regular rectangular grid
registration |
detail |
by_score | Sorting of candidates based on fitness score value
ConvergenceCriteria | ConvergenceCriteria represents an abstract base class for different convergence criteria used in registration loops
CorrespondenceEstimation | CorrespondenceEstimation represents a simple class for determining correspondences between target and query point sets/features, using nearest neighbor search
CorrespondenceEstimationBackProjection | CorrespondenceEstimationBackprojection computes correspondences as points in the target cloud which have minimum
CorrespondenceEstimationBase | Abstract CorrespondenceEstimationBase class
CorrespondenceEstimationNormalShooting | CorrespondenceEstimationNormalShooting computes correspondences as points in the target cloud which have minimum distance to normals computed on the input cloud
CorrespondenceEstimationOrganizedProjection | CorrespondenceEstimationOrganizedProjection computes correspondences by projecting the source point cloud onto the target point cloud using the camera intrinsic and extrinsic parameters
CorrespondenceRejectionOrganizedBoundary | Implements a simple correspondence rejection measure
CorrespondenceRejector | CorrespondenceRejector represents the base class for correspondence rejection methods
CorrespondenceRejectorDistance | CorrespondenceRejectorDistance implements a simple correspondence rejection method based on thresholding the distances between the correspondences
CorrespondenceRejectorFeatures | CorrespondenceRejectorFeatures implements a correspondence rejection method based on a set of feature descriptors
FeatureContainer | An inner class containing pointers to the source and target feature clouds and the parameters needed to perform the correspondence search
FeatureContainerInterface |
CorrespondenceRejectorMedianDistance | CorrespondenceRejectorMedianDistance implements a simple correspondence rejection method based on thresholding based on the median distance between the correspondences
CorrespondenceRejectorOneToOne | CorrespondenceRejectorOneToOne implements a correspondence rejection method based on eliminating duplicate match indices in the correspondences
CorrespondenceRejectorPoly | 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
CorrespondenceRejectorSampleConsensus | CorrespondenceRejectorSampleConsensus implements a correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers)
CorrespondenceRejectorSampleConsensus2D | CorrespondenceRejectorSampleConsensus2D implements a pixel-based correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers)
CorrespondenceRejectorSurfaceNormal | CorrespondenceRejectorSurfaceNormal implements a simple correspondence rejection method based on the angle between the normals at correspondent points
CorrespondenceRejectorTrimmed | CorrespondenceRejectorTrimmed implements a correspondence rejection for 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
CorrespondenceRejectorVarTrimmed | CorrespondenceRejectoVarTrimmed implements a simple correspondence rejection method by considering as inliers a certain percentage of correspondences with the least distances
DataContainer | DataContainer is a container for the input and target point clouds and implements the interface to compute correspondence scores between correspondent points in the input and target clouds
DataContainerInterface | DataContainerInterface provides a generic interface for computing correspondence scores between correspondent points in the input and target clouds
DefaultConvergenceCriteria | DefaultConvergenceCriteria represents an instantiation of ConvergenceCriteria, and implements the following criteria for registration loop evaluation:
ELCH | ELCH (Explicit Loop Closing Heuristic) class
Vertex |
FPCSInitialAlignment | 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
GraphHandler | GraphHandler class is a wrapper for a general SLAM graph The actual graph class must fulfill the following boost::graph concepts:
GraphOptimizer | GraphOptimizer class; derive and specialize for each graph type
IncrementalRegistration | Incremental IterativeClosestPoint class
KFPCSInitialAlignment | 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
LUM | Globally Consistent Scan Matching based on an algorithm by Lu and Milios
EdgeProperties |
VertexProperties |
MatchingCandidate | Container for matching candidate consisting of
MetaRegistration | Meta Registration class
NullEstimate | NullEstimate struct
NullMeasurement | NullMeasurement struct
PoseEstimate | PoseEstimate struct
PoseMeasurement | PoseMeasurement struct
sortCorrespondencesByDistance | sortCorrespondencesByDistance : a functor for sorting correspondences by distance
sortCorrespondencesByMatchIndex | sortCorrespondencesByMatchIndex : a functor for sorting correspondences by match index
sortCorrespondencesByMatchIndexAndDistance | sortCorrespondencesByMatchIndexAndDistance : a functor for sorting correspondences by match index and distance
sortCorrespondencesByQueryIndex | sortCorrespondencesByQueryIndex : a functor for sorting correspondences by query index
sortCorrespondencesByQueryIndexAndDistance | sortCorrespondencesByQueryIndexAndDistance : a functor for sorting correspondences by query index and distance
TransformationEstimation | TransformationEstimation represents the base class for methods for transformation estimation based on:
TransformationEstimation2D | TransformationEstimation2D implements a simple 2D rigid transformation estimation (x, y, theta) for a given pair of datasets
TransformationEstimation3Point | TransformationEstimation3Points represents the class for transformation estimation based on:
TransformationEstimationDualQuaternion | TransformationEstimationDualQuaternion implements dual quaternion based estimation of the transformation aligning the given correspondences
TransformationEstimationLM | TransformationEstimationLM implements Levenberg Marquardt-based estimation of the transformation aligning the given correspondences
Functor | Base functor all the models that need non linear optimization must define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec) or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) depending on the chosen _Scalar
OptimizationFunctor |
OptimizationFunctorWithIndices |
TransformationEstimationPointToPlane | TransformationEstimationPointToPlane uses Levenberg Marquardt optimization to find the transformation that minimizes the point-to-plane distance between the given correspondences
TransformationEstimationPointToPlaneLLS | TransformationEstimationPointToPlaneLLS implements a Linear Least Squares (LLS) approximation for minimizing the point-to-plane distance between two clouds of corresponding points with normals
TransformationEstimationPointToPlaneLLSWeighted | 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
TransformationEstimationPointToPlaneWeighted | TransformationEstimationPointToPlaneWeighted uses Levenberg Marquardt optimization to find the transformation that minimizes the point-to-plane distance between the given correspondences
Functor | Base functor all the models that need non linear optimization must define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec) or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) depending on the chosen _Scalar
OptimizationFunctor |
OptimizationFunctorWithIndices |
TransformationEstimationSVD | TransformationEstimationSVD implements SVD-based estimation of the transformation aligning the given correspondences
TransformationEstimationSVDScale | TransformationEstimationSVD implements SVD-based estimation of the transformation aligning the given correspondences
TransformationEstimationSymmetricPointToPlaneLLS | TransformationEstimationSymmetricPointToPlaneLLS implements a Linear Least Squares (LLS) approximation for minimizing the symmetric point-to-plane distance between two clouds of corresponding points with normals
TransformationValidation | TransformationValidation represents the base class for methods that validate the correctness of a transformation found through TransformationEstimation
TransformationValidationEuclidean | TransformationValidationEuclidean computes an L2SQR norm between a source and target dataset
MyPointRepresentation | Internal point representation uses only 3D coordinates for L2
WarpPointRigid | Base warp point class
WarpPointRigid3D | WarpPointRigid3D enables 3D (1D rotation + 2D translation) transformations for points
WarpPointRigid6D | WarpPointRigid3D enables 6D (3D rotation + 3D translation) transformations for points
search |
BruteForce | Implementation of a simple brute force search algorithm
FlannSearch | search::FlannSearch is a generic FLANN wrapper class for the new search interface
FlannIndexCreator | Helper class that creates a FLANN index from a given FLANN matrix
KdTreeIndexCreator | Creates a FLANN KdTreeSingleIndex from the given input data
KdTreeMultiIndexCreator | Creates a FLANN KdTreeIndex of multiple randomized trees from the given input data, suitable for feature matching
KMeansIndexCreator | Creates a FLANN KdTreeSingleIndex from the given input data
KdTree | search::KdTree is a wrapper class which inherits the pcl::KdTree class for performing search functions using KdTree structure
Octree | search::Octree is a wrapper class which implements nearest neighbor search operations based on the pcl::octree::Octree structure
OrganizedNeighbor | OrganizedNeighbor is a class for optimized nearest neighbor search in organized projectable point clouds, for instance from Time-Of-Flight cameras or stereo cameras
Entry |
Search | Generic search class
segmentation |
detail |
RandomWalker | Multilabel graph segmentation using random walks
grabcut |
BoykovKolmogorov | Boost implementation of Boykov and Kolmogorov's maxflow algorithm doesn't support negative flows which makes it inappropriate for this context
Color | Structure to save RGB colors into floats
Gaussian | Gaussian structure
GaussianFitter | Helper class that fits a single Gaussian to color samples
GMM |
surface |
SimplificationRemoveUnusedVertices |
test | Test_macros.h provide helper macros for testing vectors, matrices etc
internal |
texture_mapping |
Camera | Structure to store camera pose and focal length
UvIndex | Structure that links a uv coordinate to its 3D point and face
tracking |
_ParticleXYR |
_ParticleXYRP |
_ParticleXYRPY |
_ParticleXYZR |
_ParticleXYZRPY |
ApproxNearestPairPointCloudCoherence | ApproxNearestPairPointCloudCoherence computes coherence between two pointclouds using the approximate nearest point pairs
DistanceCoherence | DistanceCoherence computes coherence between two points from the distance between them
HSVColorCoherence | HSVColorCoherence computes coherence between the two points from the color difference between them
KLDAdaptiveParticleFilterOMPTracker | KLDAdaptiveParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
KLDAdaptiveParticleFilterTracker | KLDAdaptiveParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
NearestPairPointCloudCoherence | NearestPairPointCloudCoherence computes coherence between two pointclouds using the nearest point pairs
NormalCoherence | NormalCoherence computes coherence between two points from the angle between their normals
ParticleFilterOMPTracker | ParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method in parallel, using the OpenMP standard
ParticleFilterTracker | ParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
ParticleXYR |
ParticleXYRP |
ParticleXYRPY |
ParticleXYZR |
ParticleXYZRPY |
PointCloudCoherence | PointCloudCoherence is a base class to compute coherence between the two PointClouds
PointCoherence | PointCoherence is a base class to compute coherence between the two points
PyramidalKLTTracker | Pyramidal Kanade Lucas Tomasi tracker
RGBValue |
Tracker | Tracker represents the base tracker class
traits |
detail |
PointFieldTypes | Enumeration for different numerical types
asEnum |
asEnum< bool > |
asEnum< double > |
asEnum< float > |
asEnum< std::int16_t > |
asEnum< std::int32_t > |
asEnum< std::int64_t > |
asEnum< std::int8_t > |
asEnum< std::uint16_t > |
asEnum< std::uint32_t > |
asEnum< std::uint64_t > |
asEnum< std::uint8_t > |
asType |
asType< detail::PointFieldTypes::BOOL > |
asType< detail::PointFieldTypes::FLOAT32 > |
asType< detail::PointFieldTypes::FLOAT64 > |
asType< detail::PointFieldTypes::INT16 > |
asType< detail::PointFieldTypes::INT32 > |
asType< detail::PointFieldTypes::INT64 > |
asType< detail::PointFieldTypes::INT8 > |
asType< detail::PointFieldTypes::UINT16 > |
asType< detail::PointFieldTypes::UINT32 > |
asType< detail::PointFieldTypes::UINT64 > |
asType< detail::PointFieldTypes::UINT8 > |
utils |
visualization |
context_items |
Circle |
Disk |
FilledRectangle |
Line |
Markers |
Point |
Points |
Polygon |
Rectangle |
Text |
details |
AreaPickingEvent | /brief Class representing 3D area picking events
Camera | Camera class holds a set of camera parameters together with the window pos/size
CloudActor |
CloudViewer | Simple point cloud visualization class
FEllipticArc2D | Class for storing EllipticArc; every ellipse , circle are covered by this
Figure2D | Abstract class for storing figure information
FloatImageUtils | Provide some general functionalities regarding 2d float arrays, e.g., for visualization purposes
FPoints2D | Class for storing Points
FPolygon2D | Class for Polygon
FPolyLine2D | Class for PolyLine
FQuad2D | Class for storing Quads
ImageViewer | ImageViewer is a class for 2D image visualization
ExitCallback |
ExitMainLoopTimerCallback |
ImageViewerInteractorStyle | An image viewer interactor style, tailored for ImageViewer
KeyboardEvent | /brief Class representing key hit/release events
MouseEvent |
PCLContextImageItem | Struct PCLContextImageItem a specification of vtkContextItem, used to add an image to the scene in the ImageViewer class
PCLContextItem | Struct PCLContextItem represents our own custom version of vtkContextItem, used by the ImageViewer class
PCLHistogramVisualizer | PCL histogram visualizer main class
PCLHistogramVisualizerInteractorStyle | PCL histogram visualizer interactory style class
PCLImageCanvasSource2D | PCLImageCanvasSource2D represents our own custom version of vtkImageCanvasSource2D, used by the ImageViewer class
PCLPainter2D | PCL Painter2D main class
PCLPlotter | PCL Plotter main class
PCLSimpleBufferVisualizer | PCL simple buffer visualizer main class
PCLVisualizer | PCL Visualizer main class
PCLVisualizerInteractorStyle | PCLVisualizerInteractorStyle defines an unique, custom VTK based interactory style for PCL Visualizer applications
PointCloudColorHandler | Base Handler class for PointCloud colors
PointCloudColorHandler< pcl::PCLPointCloud2 > | Base Handler class for PointCloud colors
PointCloudColorHandlerCustom | Handler for predefined user colors
PointCloudColorHandlerCustom< pcl::PCLPointCloud2 > | Handler for predefined user colors
PointCloudColorHandlerGenericField | Generic field handler class for colors
PointCloudColorHandlerGenericField< pcl::PCLPointCloud2 > | Generic field handler class for colors
PointCloudColorHandlerHSVField | HSV handler class for colors
PointCloudColorHandlerHSVField< pcl::PCLPointCloud2 > | HSV handler class for colors
PointCloudColorHandlerLabelField | Label field handler class for colors
PointCloudColorHandlerLabelField< pcl::PCLPointCloud2 > | Label field handler class for colors
PointCloudColorHandlerRandom | Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen)
PointCloudColorHandlerRandom< pcl::PCLPointCloud2 > | Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen)
PointCloudColorHandlerRGBAField | RGBA handler class for colors
PointCloudColorHandlerRGBAField< pcl::PCLPointCloud2 > | RGBA handler class for colors
PointCloudColorHandlerRGBField | RGB handler class for colors
PointCloudColorHandlerRGBField< pcl::PCLPointCloud2 > | RGB handler class for colors
PointCloudColorHandlerRGBHack |
PointCloudGeometryHandler | Base handler class for PointCloud geometry
PointCloudGeometryHandler< pcl::PCLPointCloud2 > | Base handler class for PointCloud geometry
PointCloudGeometryHandlerCustom | Custom handler class for PointCloud geometry
PointCloudGeometryHandlerCustom< pcl::PCLPointCloud2 > | Custom handler class for PointCloud geometry
PointCloudGeometryHandlerSurfaceNormal | Surface normal handler class for PointCloud geometry
PointCloudGeometryHandlerSurfaceNormal< pcl::PCLPointCloud2 > | Surface normal handler class for PointCloud geometry
PointCloudGeometryHandlerXYZ | XYZ handler class for PointCloud geometry
PointCloudGeometryHandlerXYZ< pcl::PCLPointCloud2 > | XYZ handler class for PointCloud geometry
PointPickingCallback |
PointPickingEvent | /brief Class representing 3D point picking events
RangeImageVisualizer | Range image visualizer class
RenWinInteract |
Window |
ExitCallback |
ExitMainLoopTimerCallback |
_Axis |
_Intensity |
_Intensity32u |
_Intensity8u |
_Normal |
_PointDEM |
_PointNormal |
_PointSurfel |
_PointWithRange |
_PointWithScale |
_PointWithViewpoint |
_PointXYZ |
_PointXYZHSV |
_PointXYZI | A point structure representing Euclidean xyz coordinates, and the intensity value
_PointXYZINormal |
_PointXYZL |
_PointXYZLAB |
_PointXYZLNormal |
_PointXYZRGB |
_PointXYZRGBA |
_PointXYZRGBL |
_PointXYZRGBNormal |
_ReferenceFrame | A structure representing the Local Reference Frame of a point
_RGB |
AdaptiveCostSOStereoMatching | Adaptive Cost 2-pass Scanline Optimization Stereo Matching class
AdaptiveRangeCoder | AdaptiveRangeCoder compression class
AgastKeypoint2D | Detects 2D AGAST corner points
AgastKeypoint2D< pcl::PointXYZ, pcl::PointUV > | Detects 2D AGAST corner points
AgastKeypoint2DBase | Detects 2D AGAST corner points
ApproximateProgressiveMorphologicalFilter | Implements the Progressive Morphological Filter for segmentation of ground points
ApproximateVoxelGrid | ApproximateVoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
ASCIIReader | Ascii Point Cloud Reader
Axis | A point structure representing an Axis using its normal coordinates
BadArgumentException | An exception that is thrown when the arguments number or type is wrong/unhandled
BearingAngleImage | Class BearingAngleImage is used as an interface to generate Bearing Angle(BA) image
BilateralFilter | A bilateral filter implementation for point cloud data
BilateralUpsampling | Bilateral filtering implementation, based on the following paper:
BinaryTreeThresholdBasedBranchEstimator | Branch estimator for binary trees where the branch is computed only from the threshold
BivariatePolynomialT | This represents a bivariate polynomial and provides some functionality for it
BlockBasedStereoMatching | Block based (or fixed window) Stereo Matching class
BOARDLocalReferenceFrameEstimation | BOARDLocalReferenceFrameEstimation implements the BOrder Aware Repeatable Directions algorithm for local reference frame estimation as described here:
BorderDescription | A structure to store if a point in a range image lies on a border between an obstacle and the background
Boundary | A point structure representing a description of whether a point is lying on a surface boundary or not
BoundaryEstimation | BoundaryEstimation estimates whether a set of points is lying on surface boundaries using an angle criterion
BoundingBoxXYZ |
BoxClipper3D | Implementation of a box clipper in 3D. Actually it allows affine transformations, thus any parallelepiped in general pose. The affine transformation is used to transform the point before clipping it using a cube centered at origin and with an extend of -1 to +1 in each dimension
BranchEstimator | Interface for branch estimators
BRISK2DEstimation | Implementation of the BRISK-descriptor, based on the original code and paper reference by
BriskKeypoint2D | Detects BRISK interest points based on the original code and paper reference by
BRISKSignature512 | A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK)
Clipper3D | Base class for 3D clipper objects
CloudIterator | Iterator class for point clouds with or without given indices
CloudSurfaceProcessing | CloudSurfaceProcessing represents the base class for algorithms that takes a point cloud as input and produces a new output cloud that has been modified towards a better surface representation
ColorGradientDOTModality |
Candidate |
ColorGradientModality | Modality based on max-RGB gradients
Candidate | Candidate for a feature (used in feature extraction methods)
ColorLUT |
ColorModality |
Candidate |
Comparator | Comparator is the base class for comparators that compare two points given some function
ComparisonBase | The (abstract) base class for the comparison object
ComputeFailedException |
ConcaveHull | ConcaveHull (alpha shapes) using libqhull library
ConditionalEuclideanClustering | ConditionalEuclideanClustering performs segmentation based on Euclidean distance and a user-defined clustering condition
ConditionalRemoval | ConditionalRemoval filters data that satisfies certain conditions
ConditionAnd | AND condition
ConditionBase | Base condition class
ConditionOr | OR condition
ConstCloudIterator | Iterator class for point clouds with or without given indices
ConstIteratorIdx |
DefaultConstIterator |
ConvexHull | ConvexHull using libqhull library
Convolution | A 2D convolution class
CopyIfFieldExists | A helper functor that can copy a specific value if the given field exists
Correspondence | Correspondence represents a match between two entities (e.g., points, descriptors, etc)
CorrespondenceGrouping | Abstract base class for Correspondence Grouping algorithms
CovarianceSampling | Point Cloud sampling based on the 6D covariances
CPCSegmentation | A segmentation algorithm partitioning a supervoxel graph
CPPFEstimation | Class that calculates the "surflet" features for each pair in the given pointcloud
CPPFSignature | A point structure for storing the Point Pair Feature (CPPF) values
CrfNormalSegmentation |
CrfSegmentation |
CRHAlignment | CRHAlignment uses two Camera Roll Histograms (CRH) to find the roll rotation that aligns both views
CRHEstimation | CRHEstimation estimates the Camera Roll Histogram (CRH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in:
CropBox | CropBox is a filter that allows the user to filter all the data inside of a given box
CropBox< pcl::PCLPointCloud2 > | CropBox is a filter that allows the user to filter all the data inside of a given box
CropHull | Filter points that lie inside or outside a 3D closed surface or 2D closed polygon, as generated by the ConvexHull or ConcaveHull classes
CustomPointRepresentation | CustomPointRepresentation extends PointRepresentation to allow for sub-part selection on the point
CVFHEstimation | CVFHEstimation estimates the Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in:
DavidSDKGrabber | Grabber for davidSDK structured light compliant devices
DecisionForest | Class representing a decision forest
DecisionForestEvaluator | Utility class for evaluating a decision forests
DecisionForestTrainer | Trainer for decision trees
DecisionTree | Class representing a decision tree
DecisionTreeEvaluator | Utility class for evaluating a decision tree
DecisionTreeTrainer | Trainer for decision trees
DecisionTreeTrainerDataProvider |
DefaultFeatureRepresentation | DefaulFeatureRepresentation extends PointRepresentation and is intended to be used when defining the default behavior for feature descriptor types (i.e., copy each element of each field into a float array)
DefaultIterator |
DefaultPointRepresentation | DefaultPointRepresentation extends PointRepresentation to define default behavior for common point types
DefaultPointRepresentation< FPFHSignature33 > |
DefaultPointRepresentation< GASDSignature512 > |
DefaultPointRepresentation< GASDSignature7992 > |
DefaultPointRepresentation< GASDSignature984 > |
DefaultPointRepresentation< Narf36 > |
DefaultPointRepresentation< NormalBasedSignature12 > |
DefaultPointRepresentation< PFHRGBSignature250 > |
DefaultPointRepresentation< PFHSignature125 > |
DefaultPointRepresentation< PointNormal > |
DefaultPointRepresentation< PointXYZ > |
DefaultPointRepresentation< PointXYZI > |
DefaultPointRepresentation< PPFSignature > |
DefaultPointRepresentation< ShapeContext1980 > |
DefaultPointRepresentation< SHOT1344 > |
DefaultPointRepresentation< SHOT352 > |
DefaultPointRepresentation< UniqueShapeContext1960 > |
DefaultPointRepresentation< VFHSignature308 > |
DenseCrf |
DenseQuantizedMultiModTemplate |
DenseQuantizedSingleModTemplate |
DepthSenseGrabber | Grabber for DepthSense devices (e.g
DifferenceOfNormalsEstimation | A Difference of Normals (DoN) scale filter implementation for point cloud data
DigitalElevationMapBuilder | Build a Digital Elevation Map in the column-disparity space from a disparity map and a color image of the scene
DinastGrabber | Grabber for DINAST devices (i.e., IPA-1002, IPA-1110, IPA-2001)
DisparityMapConverter | Compute point cloud from the disparity map
DistanceMap | Represents a distance map obtained from a distance transformation
DOTMOD | Template matching using the DOTMOD approach
DOTModality |
DOTMODDetection |
EarClipping | The ear clipping triangulation algorithm
Edge |
EdgeAwarePlaneComparator | EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
EnergyMaps | Stores a set of energy maps
EnsensoGrabber | Grabber for IDS-Imaging Ensenso's devices
ESFEstimation | ESFEstimation estimates the ensemble of shape functions descriptors for a given point cloud dataset containing points
ESFSignature640 | A point structure representing the Ensemble of Shape Functions (ESF)
EuclideanClusterComparator | EuclideanClusterComparator is a comparator used for finding clusters based on euclidean distance
EuclideanClusterExtraction | EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense
EuclideanPlaneCoefficientComparator | EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
EventFrequency | A helper class to measure frequency of a certain event
ExtractIndices | ExtractIndices extracts a set of indices from a point cloud
ExtractIndices< pcl::PCLPointCloud2 > | ExtractIndices extracts a set of indices from a point cloud
ExtractPolygonalPrismData | ExtractPolygonalPrismData uses a set of point indices that represent a planar model, and together with a given height, generates a 3D polygonal prism
FarthestPointSampling | FarthestPointSampling applies farthest point sampling using euclidean distance, starting with a random point, utilizing a naive method
FastBilateralFilter | Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper:
Array3D |
FastBilateralFilterOMP | Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper:
Feature | Feature represents the base feature class
FeatureFromLabels |
FeatureFromNormals |
FeatureHandler | Utility class interface which is used for creating and evaluating features
FeatureHistogram | Type for histograms for computing mean and variance of some floats
FeatureWithLocalReferenceFrames | FeatureWithLocalReferenceFrames provides a public interface for descriptor extractor classes which need a local reference frame at each input keypoint
Fern | Class representing a Fern
FernEvaluator | Utility class for evaluating a fern
FernTrainer | Trainer for a Fern
FieldComparison | The field-based specialization of the comparison object
FieldMatches |
FileGrabber | FileGrabber provides a container-style interface for grabbers which operate on fixed-size input
FileReader | Point Cloud Data (FILE) file format reader interface
FileWriter | Point Cloud Data (FILE) file format writer
Filter | Filter represents the base filter class
Filter< pcl::PCLPointCloud2 > | Filter represents the base filter class
FilterIndices | FilterIndices represents the base class for filters that are about binary point removal
FilterIndices< pcl::PCLPointCloud2 > | FilterIndices represents the base class for filters that are about binary point removal
FLARELocalReferenceFrameEstimation | FLARELocalReferenceFrameEstimation implements the Fast LocAl Reference framE algorithm for local reference frame estimation as described here:
for_each_type_impl |
for_each_type_impl< false > |
FPFHEstimation | FPFHEstimation estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals
FPFHEstimationOMP | FPFHEstimationOMP estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals, in parallel, using the OpenMP standard
FPFHSignature33 | A point structure representing the Fast Point Feature Histogram (FPFH)
FrustumCulling | FrustumCulling filters points inside a frustum given by pose and field of view of the camera
Functor | Base functor all the models that need non linear optimization must define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec) or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) depending on the chosen _Scalar
GASDColorEstimation | GASDColorEstimation estimates the Globally Aligned Spatial Distribution (GASD) descriptor for a given point cloud dataset given XYZ and RGB data
GASDEstimation | GASDEstimation estimates the Globally Aligned Spatial Distribution (GASD) descriptor for a given point cloud dataset given XYZ data
GASDSignature512 | A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor
GASDSignature7992 | A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor
GASDSignature984 | A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor
GaussianKernel | Class GaussianKernel assembles all the method for computing, convolving, smoothing, gradients computing an image using a gaussian kernel
GeneralizedIterativeClosestPoint | GeneralizedIterativeClosestPoint is an ICP variant that implements the generalized iterative closest point algorithm as described by Alex Segal et al
OptimizationFunctorWithIndices | Optimization functor structure
GeneralizedIterativeClosestPoint6D | GeneralizedIterativeClosestPoint6D integrates L*a*b* color space information into the Generalized Iterative Closest Point (GICP) algorithm
MyPointRepresentation | Custom point representation to perform kdtree searches in more than 3 (i.e
GeometricConsistencyGrouping | Class implementing a 3D correspondence grouping enforcing geometric consistency among feature correspondences
GFPFHEstimation | GFPFHEstimation estimates the Global Fast Point Feature Histogram (GFPFH) descriptor for a given point cloud dataset containing points and labels
GFPFHSignature16 | A point structure representing the GFPFH descriptor with 16 bins
GlobalHypothesesVerification | A hypothesis verification method proposed in "A Global Hypotheses Verification Method for 3D Object Recognition", A
Grabber | Grabber interface for PCL 1.x device drivers
GrabCut | Implementation of the GrabCut segmentation in "GrabCut — Interactive Foreground Extraction using Iterated Graph Cuts" by Carsten Rother, Vladimir Kolmogorov and Andrew Blake
NLinks |
GradientXY | A point structure representing Euclidean xyz coordinates, and the intensity value
GraphRegistration | GraphRegistration class is the base class for graph-based registration methods
GrayStereoMatching | Stereo Matching abstract class for Grayscale images
GreedyProjectionTriangulation | GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points based on local 2D projections
GreedyVerification | A greedy hypothesis verification method
GridMinimum | GridMinimum assembles a local 2D grid over a given PointCloud, and downsamples the data
GridProjection | Grid projection surface reconstruction method
Leaf | Data leaf
GroundPlaneComparator | GroundPlaneComparator is a Comparator for detecting smooth surfaces suitable for driving
GRSDEstimation | GRSDEstimation estimates the Global Radius-based Surface Descriptor (GRSD) for a given point cloud dataset containing points and normals
GRSDSignature21 | A point structure representing the Global Radius-based Surface Descriptor (GRSD)
HarrisKeypoint2D | HarrisKeypoint2D detects Harris corners family points
HarrisKeypoint3D | HarrisKeypoint3D uses the idea of 2D Harris keypoints, but instead of using image gradients, it uses surface normals
HarrisKeypoint6D | Keypoint detector for detecting corners in 3D (XYZ), 2D (intensity) AND mixed versions of these
has_custom_allocator | Tests at compile time if type T has a custom allocator
HashTableOLD |
HDLGrabber | Grabber for the Velodyne High-Definition-Laser (HDL)
HDLDataPacket |
HDLFiringData |
HDLLaserCorrection |
HDLLaserReturn |
Histogram | A point structure representing an N-D histogram
Hough3DGrouping | Class implementing a 3D correspondence grouping algorithm that can deal with multiple instances of a model template found into a given scene
HypothesisVerification | Abstract class for hypotheses verification methods
IFSReader | Indexed Face set (IFS) file format reader
IFSWriter | Point Cloud Data (IFS) file format writer
ImageGrabber |
ImageGrabberBase | Base class for Image file grabber
InitFailedException | An exception thrown when init can not be performed should be used in all the PCLBase class inheritants
IntegralImage2D | Determines an integral image representation for a given organized data array
IntegralImage2D< DataType, 1 > | Partial template specialization for integral images with just one channel
IntegralImageNormalEstimation | Surface normal estimation on organized data using integral images
IntegralImageTypeTraits |
IntegralImageTypeTraits< char > |
IntegralImageTypeTraits< float > |
IntegralImageTypeTraits< int > |
IntegralImageTypeTraits< short > |
IntegralImageTypeTraits< unsigned char > |
IntegralImageTypeTraits< unsigned int > |
IntegralImageTypeTraits< unsigned short > |
Intensity | A point structure representing the grayscale intensity in single-channel images
Intensity32u | A point structure representing the grayscale intensity in single-channel images
Intensity8u | A point structure representing the grayscale intensity in single-channel images
IntensityGradient | A point structure representing the intensity gradient of an XYZI point cloud
IntensityGradientEstimation | IntensityGradientEstimation estimates the intensity gradient for a point cloud that contains position and intensity values
IntensitySpinEstimation | IntensitySpinEstimation estimates the intensity-domain spin image descriptors for a given point cloud dataset containing points and intensity
InterestPoint | A point structure representing an interest point with Euclidean xyz coordinates, and an interest value
intersect |
InvalidConversionException | An exception that is thrown when a PCLPointCloud2 message cannot be converted into a PCL type
InvalidSACModelTypeException | An exception that is thrown when a sample consensus model doesn't have the correct number of samples defined in model_types.h
IOException | An exception that is thrown during an IO error (typical read/write errors)
ISMPeak | This struct is used for storing peak
IsNotDenseException | An exception that is thrown when a PointCloud is not dense but is attempted to be used as dense
ISSKeypoint3D | ISSKeypoint3D detects the Intrinsic Shape Signatures keypoints for a given point cloud
IterativeClosestPoint | IterativeClosestPoint provides a base implementation of the Iterative Closest Point algorithm
IterativeClosestPointNonLinear | IterativeClosestPointNonLinear is an ICP variant that uses Levenberg-Marquardt optimization backend
IterativeClosestPointWithNormals | IterativeClosestPointWithNormals is a special case of IterativeClosestPoint, that uses a transformation estimated based on Point to Plane distances by default
IteratorIdx |
JointIterativeClosestPoint | JointIterativeClosestPoint extends ICP to multiple frames which share the same transform
KdTree | KdTree represents the base spatial locator class for kd-tree implementations
KdTreeFLANN | KdTreeFLANN is a generic type of 3D spatial locator using kD-tree structures
kernel |
KernelWidthTooSmallException | An exception that is thrown when the kernel size is too small
Keypoint | Keypoint represents the base class for key points
Kmeans | K-means clustering
Label |
LabeledEuclideanClusterExtraction | LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info
LCCPSegmentation | A simple segmentation algorithm partitioning a supervoxel graph into groups of locally convex connected supervoxels separated by concave borders
LeastMedianSquares | LeastMedianSquares represents an implementation of the LMedS (Least Median of Squares) algorithm
LinearizedMaps | Stores a set of linearized maps
LinearLeastSquaresNormalEstimation | Surface normal estimation on dense data using a least-squares estimation based on a first-order Taylor approximation
LineIterator | Organized Index Iterator for iterating over the "pixels" for a given line using the Bresenham algorithm
LINEMOD | Template matching using the LINEMOD approach
LINEMOD_OrientationMap | Map that stores orientations
LINEMODDetection | Represents a detection of a template using the LINEMOD approach
LineRGBD | High-level class for template matching using the LINEMOD approach based on RGB and Depth data
Detection | A LineRGBD detection
LocalMaximum | LocalMaximum downsamples the cloud, by eliminating points that are locally maximal
MarchingCubes | The marching cubes surface reconstruction algorithm
MarchingCubesHoppe | The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance from tangent planes, proposed by Hoppe et
MarchingCubesRBF | The marching cubes surface reconstruction algorithm, using a signed distance function based on radial basis functions
MaskMap |
MaximumLikelihoodSampleConsensus | MaximumLikelihoodSampleConsensus represents an implementation of the MLESAC (Maximum Likelihood Estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S
MedianFilter | Implementation of the median filter
MeshConstruction | MeshConstruction represents a base surface reconstruction class
MeshProcessing | MeshProcessing represents the base class for mesh processing algorithms
MeshQuadricDecimationVTK | PCL mesh decimation based on vtkQuadricDecimation from the VTK library
MeshSmoothingLaplacianVTK | PCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library
MeshSmoothingWindowedSincVTK | PCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library
MeshSubdivisionVTK | PCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library
MEstimatorSampleConsensus | 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
MinCutSegmentation | This class implements the segmentation algorithm based on minimal cut of the graph
MLSResult | Data structure used to store the results of the MLS fitting
MLSProjectionResults | Data structure used to store the MLS projection results
PolynomialPartialDerivative | Data structure used to store the MLS polynomial partial derivatives
ModelCoefficients |
ModelOutlierRemoval | ModelOutlierRemoval filters points in a cloud based on the distance between model and point
MomentInvariants | A point structure representing the three moment invariants
MomentInvariantsEstimation | MomentInvariantsEstimation estimates the 3 moment invariants (j1, j2, j3) at each 3D point
MomentOfInertiaEstimation | Implements the method for extracting features based on moment of inertia
Morphology |
MovingLeastSquares | MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm for data smoothing and improved normal estimation
MLSVoxelGrid | A minimalistic implementation of a voxel grid, necessary for the point cloud upsampling
Leaf |
MTLReader |
MultiChannel2DComparisonFeature | Feature for comparing two sample points in 2D multi-channel data
MultiChannel2DComparisonFeatureHandler | Feature utility class that handles the creation and evaluation of RGBD comparison features
MultiChannel2DData | Holds two-dimensional multi-channel data
MultiChannel2DDataSet | Holds a set of two-dimensional multi-channel data
MultipleData2DExampleIndex | Example index for a set of 2D data blocks
MultiscaleFeaturePersistence | Generic class for extracting the persistent features from an input point cloud It can be given any Feature estimator instance and will compute the features of the input over a multiscale representation of the cloud and output the unique ones over those scales
Narf | NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data
FeaturePointRepresentation |
Narf36 | A point structure representing the Narf descriptor
NarfDescriptor | Computes NARF feature descriptors for points in a range image See B
Parameters |
NarfKeypoint | NARF (Normal Aligned Radial Feature) keypoints
Parameters | Parameters used in this class
NdCentroidFunctor | Helper functor structure for n-D centroid estimation
NdConcatenateFunctor | Helper functor structure for concatenate
NdCopyEigenPointFunctor | Helper functor structure for copying data between an Eigen type and a PointT
NdCopyPointEigenFunctor | Helper functor structure for copying data between an Eigen type and a PointT
Normal | A point structure representing normal coordinates and the surface curvature estimate
NormalBasedSignature12 | A point structure representing the Normal Based Signature for a feature matrix of 4-by-3
NormalBasedSignatureEstimation | Normal-based feature signature estimation class
NormalDistributionsTransform | A 3D Normal Distribution Transform registration implementation for point cloud data
NormalDistributionsTransform2D | NormalDistributionsTransform2D provides an implementation of the Normal Distributions Transform algorithm for scan matching
NormalEstimation | NormalEstimation estimates local surface properties (surface normals and curvatures)at each 3D point
NormalEstimationOMP | NormalEstimationOMP estimates local surface properties at each 3D point, such as surface normals and curvatures, in parallel, using the OpenMP standard
NormalRefinement | Normal vector refinement class
NormalSpaceSampling | NormalSpaceSampling samples the input point cloud in the space of normal directions computed at every point
NotEnoughPointsException | An exception that is thrown when the number of correspondents is not equal to the minimum required
OBJReader |
ONIGrabber | A simple ONI grabber
OpenNIGrabber | Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
modeComp |
OrganizedConnectedComponentSegmentation | OrganizedConnectedComponentSegmentation allows connected components to be found within organized point cloud data, given a comparison function
OrganizedEdgeBase | OrganizedEdgeBase, OrganizedEdgeFromRGB, OrganizedEdgeFromNormals, and OrganizedEdgeFromRGBNormals find 3D edges from an organized point cloud data
Neighbor |
OrganizedEdgeFromNormals |
OrganizedEdgeFromRGB |
OrganizedEdgeFromRGBNormals |
OrganizedFastMesh | Simple triangulation/surface reconstruction for organized point clouds
OrganizedIndexIterator | Base class for iterators on 2-dimensional maps like images/organized clouds etc
OrganizedMultiPlaneSegmentation | OrganizedMultiPlaneSegmentation finds all planes present in the input cloud, and outputs a vector of plane equations, as well as a vector of point clouds corresponding to the inliers of each detected plane
OrganizedNeighborSearch | OrganizedNeighborSearch class
nearestNeighborCandidate | nearestNeighborCandidate entry for the nearest neighbor candidate queue
radiusSearchLoopkupEntry | radiusSearchLoopkupEntry entry for radius search lookup vector
OURCVFHEstimation | OURCVFHEstimation estimates the Oriented, Unique and Repetable Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given point cloud dataset given XYZ data and normals, as presented in:
PackedHSIComparison | A packed HSI specialization of the comparison object
PackedRGBComparison | A packed rgb specialization of the comparison object
PairwiseGraphRegistration | PairwiseGraphRegistration class aligns the clouds two by two
PairwisePotential |
PapazovHV | A hypothesis verification method proposed in "An Efficient RANSAC for 3D Object Recognition in Noisy and Occluded Scenes", C
PassThrough | PassThrough passes points in a cloud based on constraints for one particular field of the point type
PassThrough< pcl::PCLPointCloud2 > | PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints
PCA | Principal Component analysis (PCA) class
PCDGrabber |
PCDGrabberBase | Base class for PCD file grabber
PCDReader | Point Cloud Data (PCD) file format reader
PCDWriter | Point Cloud Data (PCD) file format writer
PCLBase | PCL base class
PCLBase< pcl::PCLPointCloud2 > |
PCLException | A base class for all pcl exceptions which inherits from std::runtime_error
PCLHeader |
PCLImage |
PCLPointCloud2 |
PCLPointField |
PCLSurfaceBase | Pure abstract class
Permutohedral | Implementation of a high-dimensional gaussian filtering using the permutohedral lattice
Neighbors |
PFHEstimation | PFHEstimation estimates the Point Feature Histogram (PFH) descriptor for a given point cloud dataset containing points and normals
PFHRGBEstimation | Similar to the Point Feature Histogram descriptor, but also takes color into account
PFHRGBSignature250 | A point structure representing the Point Feature Histogram with colors (PFHRGB)
PFHSignature125 | A point structure representing the Point Feature Histogram (PFH)
PiecewiseLinearFunction | This provides functionalities to efficiently return values for piecewise linear function
PlanarPolygon | PlanarPolygon represents a planar (2D) polygon, potentially in a 3D space
PlanarPolygonFusion | PlanarPolygonFusion takes a list of 2D planar polygons and attempts to reduce them to a minimum set that best represents the scene, based on various given comparators
PlanarRegion | PlanarRegion represents a set of points that lie in a plane
PlaneClipper3D | Implementation of a plane clipper in 3D
PlaneCoefficientComparator | PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
PlaneRefinementComparator | PlaneRefinementComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
PLYReader | Point Cloud Data (PLY) file format reader
PLYWriter | Point Cloud Data (PLY) file format writer
PointCloud | PointCloud represents the base class in PCL for storing collections of 3D points
PointCorrespondence3D | Representation of a (possible) correspondence between two 3D points in two different coordinate frames (e.g
PointCorrespondence6D | Representation of a (possible) correspondence between two points (e.g
PointDataAtOffset | A datatype that enables type-correct comparisons
PointDEM | A point structure representing Digital Elevation Map
PointIndices |
PointNormal | A point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate
PointRepresentation | PointRepresentation provides a set of methods for converting a point structs/object into an n-dimensional vector
PointSurfel | A surfel, that is, a point structure representing Euclidean xyz coordinates, together with normal coordinates, a RGBA color, a radius, a confidence value and the surface curvature estimate
PointUV | A 2D point structure representing pixel image coordinates
PointWithRange | A point structure representing Euclidean xyz coordinates, padded with an extra range float
PointWithScale | A point structure representing a 3-D position and scale
PointWithViewpoint | A point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen
PointXY | A 2D point structure representing Euclidean xy coordinates
PointXY32f | 2D point with float x- and y-coordinates
PointXY32i | 2D point with integer x- and y-coordinates
PointXYZ | A point structure representing Euclidean xyz coordinates
PointXYZHSV |
PointXYZI |
PointXYZIEdge | Point cloud containing edge information
PointXYZINormal | A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate
PointXYZL |
PointXYZLAB | A point structure representing Euclidean xyz coordinates, and the CIELAB color
PointXYZLNormal | A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates and the surface curvature estimate
PointXYZRGB | A point structure representing Euclidean xyz coordinates, and the RGB color
PointXYZRGBA | A point structure representing Euclidean xyz coordinates, and the RGBA color
PointXYZRGBL |
PointXYZRGBNormal | A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate
Poisson | The Poisson surface reconstruction algorithm
PolygonMesh |
PolynomialCalculationsT | This provides some functionality for polynomials, like finding roots or approximating bivariate polynomials
Parameters | Parameters used in this class
PosesFromMatches | Calculate 3D transformation based on point correspondences
Parameters | Parameters used in this class
PoseEstimate | A result of the pose estimation process
IsBetter |
PPFEstimation | Class that calculates the "surflet" features for each pair in the given pointcloud
PPFHashMapSearch |
HashKeyStruct | Data structure to hold the information for the key in the feature hash map of the PPFHashMapSearch class
PPFRegistration | Class that registers two point clouds based on their sets of PPFSignatures
PoseWithVotes | Structure for storing a pose (represented as an Eigen::Affine3f) and an integer for counting votes
PPFRGBEstimation |
PPFRGBRegionEstimation |
PPFRGBSignature | A point structure for storing the Point Pair Color Feature (PPFRGB) values
PPFSignature | A point structure for storing the Point Pair Feature (PPF) values
PrincipalCurvatures | A point structure representing the principal curvatures and their magnitudes
PrincipalCurvaturesEstimation | PrincipalCurvaturesEstimation estimates the directions (eigenvectors) and magnitudes (eigenvalues) of principal surface curvatures for a given point cloud dataset containing points and normals
PrincipalRadiiRSD | A point structure representing the minimum and maximum surface radii (in meters) computed using RSD
ProgressiveMorphologicalFilter | Implements the Progressive Morphological Filter for segmentation of ground points
ProgressiveSampleConsensus | ProgressiveSampleConsensus represents an implementation of the PROSAC (PROgressive SAmple Consensus) algorithm, as described in: "Matching with PROSAC – Progressive Sample Consensus", Chum, O
ProjectInliers | ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud
ProjectInliers< pcl::PCLPointCloud2 > | ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud
PyramidFeatureHistogram | Class that compares two sets of features by using a multiscale representation of the features inside a pyramid
QuantizableModality | Interface for a quantizable modality
QuantizedMap |
QuantizedMultiModFeature | Feature that defines a position and quantized value in a specific modality
QuantizedNormalLookUpTable | Look-up-table for fast surface normal quantization
RadiusOutlierRemoval | RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have
RadiusOutlierRemoval< pcl::PCLPointCloud2 > | RadiusOutlierRemoval is a simple filter that removes outliers if the number of neighbors in a certain search radius is smaller than a given K
RandomizedMEstimatorSampleConsensus | 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)
RandomizedRandomSampleConsensus | RandomizedRandomSampleConsensus represents an implementation of the RRANSAC (Randomized RANdom SAmple Consensus), as described in "Randomized RANSAC with Td,d test", O
RandomSample | RandomSample applies a random sampling with uniform probability
RandomSample< pcl::PCLPointCloud2 > | RandomSample applies a random sampling with uniform probability
RandomSampleConsensus | RandomSampleConsensus represents an implementation of the RANSAC (RANdom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography", Martin A
RangeImage | RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where a 3D scene was captured from a specific view point
RangeImageBorderExtractor | Extract obstacle borders from range images, meaning positions where there is a transition from foreground to background
LocalSurface | Stores some information extracted from the neighborhood of a point
Parameters | Parameters used in this class
ShadowBorderIndices | Stores the indices of the shadow border corresponding to obstacle borders

RangeImagePlanar

RangeImagePlanar is derived from the original range image and differs from it because it's not a spherical projection, but using a projection plane (as normal cameras do), therefore being better applicable for range sensors that already provide a range image by themselves (stereo cameras, ToF-cameras), so that a conversion to point cloud and then to a spherical range image becomes unnecessary

RangeImageSpherical | RangeImageSpherical is derived from the original range image and uses a slightly different spherical projection
RealSense2Grabber | Grabber for Intel Realsense 2 SDK devices (D400 series)
RealSenseGrabber |
Mode | A descriptor for capturing mode
ReferenceFrame |
Region3D | Region3D represents summary statistics of a 3D collection of points
RegionGrowing | Implements the well known Region Growing algorithm used for segmentation
RegionGrowingRGB | Implements the well known Region Growing algorithm used for segmentation based on color of points
RegionXY | Defines a region in XY-space
Registration | Registration represents the base registration class for general purpose, ICP-like methods
RegistrationVisualizer | RegistrationVisualizer represents the base class for rendering the intermediate positions occupied by the source point cloud during it's registration to the target point cloud
RegressionVarianceNode | Node for a regression trees which optimizes variance
RegressionVarianceStatsEstimator | Statistics estimator for regression trees which optimizes variance
RFFaceDetectorTrainer |
RGB | A structure representing RGB color information
RGBPlaneCoefficientComparator | RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
RIFTEstimation | RIFTEstimation estimates the Rotation Invariant Feature Transform descriptors for a given point cloud dataset containing points and intensity
RobotEyeGrabber | Grabber for the Ocular Robotics RobotEye sensor
ROPSEstimation | This class implements the method for extracting RoPS features presented in the article "Rotational Projection Statistics for 3D Local Surface Description and Object Recognition" by Yulan Guo, Ferdous Sohel, Mohammed Bennamoun, Min Lu and Jianwei Wan
RSDEstimation | RSDEstimation estimates the Radius-based Surface Descriptor (minimal and maximal radius of the local surface's curves) for a given point cloud dataset containing points and normals
SACSegmentation | 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
SACSegmentationFromNormals | SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and models that require the use of surface normals for estimation
SampleConsensus | SampleConsensus represents the base class
SampleConsensusInitialAlignment | SampleConsensusInitialAlignment is an implementation of the initial alignment algorithm described in section IV of "Fast Point Feature Histograms (FPFH) for 3D Registration," Rusu et al
ErrorFunctor |
HuberPenalty |
TruncatedError |
SampleConsensusModel | SampleConsensusModel represents the base model class
SampleConsensusModelCircle2D | SampleConsensusModelCircle2D defines a model for 2D circle segmentation on the X-Y plane
SampleConsensusModelCircle3D | SampleConsensusModelCircle3D defines a model for 3D circle segmentation
SampleConsensusModelCone | SampleConsensusModelCone defines a model for 3D cone segmentation
SampleConsensusModelCylinder | SampleConsensusModelCylinder defines a model for 3D cylinder segmentation
SampleConsensusModelEllipse3D | SampleConsensusModelEllipse3D defines a model for 3D ellipse segmentation
SampleConsensusModelFromNormals | SampleConsensusModelFromNormals represents the base model class for models that require the use of surface normals for estimation
SampleConsensusModelLine | SampleConsensusModelLine defines a model for 3D line segmentation
SampleConsensusModelNormalParallelPlane | SampleConsensusModelNormalParallelPlane defines a model for 3D plane segmentation using additional surface normal constraints
SampleConsensusModelNormalPlane | SampleConsensusModelNormalPlane defines a model for 3D plane segmentation using additional surface normal constraints
SampleConsensusModelNormalSphere | SampleConsensusModelNormalSphere defines a model for 3D sphere segmentation using additional surface normal constraints
SampleConsensusModelParallelLine | SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular constraints
SampleConsensusModelParallelPlane | SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional angular constraints
SampleConsensusModelPerpendicularPlane | SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional angular constraints
SampleConsensusModelPlane | SampleConsensusModelPlane defines a model for 3D plane segmentation
SampleConsensusModelRegistration | SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection
SampleConsensusModelRegistration2D | SampleConsensusModelRegistration2D defines a model for Point-To-Point registration outlier rejection using distances between 2D pixels
SampleConsensusModelSphere | SampleConsensusModelSphere defines a model for 3D sphere segmentation
SampleConsensusModelStick | SampleConsensusModelStick defines a model for 3D stick segmentation
SampleConsensusModelTorus | SampleConsensusModelTorus defines a model for 3D torus segmentation
SampleConsensusPrerejective | Pose estimation and alignment class using a prerejective RANSAC routine
SamplingSurfaceNormal | SamplingSurfaceNormal divides the input space into grids until each grid contains a maximum of N points, and samples points randomly within each grid
ScaledMultiChannel2DComparisonFeatureHandler | Feature utility class that handles the creation and evaluation of RGBD comparison features
ScaledMultiChannel2DComparisonFeatureHandlerCCodeGenerator |
ScopeTime | Class to measure the time spent in a scope
SeededHueSegmentation | SeededHueSegmentation
SegmentDifferences | SegmentDifferences obtains the difference between two spatially aligned point clouds and returns the difference between them for a maximum given distance threshold
SetIfFieldExists | A helper functor that can set a specific value in a field if the field exists
ShadowPoints | ShadowPoints removes the ghost points appearing on edge discontinuties
ShapeContext1980 | A point structure representing a Shape Context
ShapeContext3DEstimation | ShapeContext3DEstimation implements the 3D shape context descriptor as described in:
SHOT1344 | A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+color
SHOT352 | A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape only
SHOTColorEstimation | SHOTColorEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points, normals and colors
SHOTColorEstimationOMP | SHOTColorEstimationOMP estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points, normals and colors, in parallel, using the OpenMP standard
SHOTEstimation | SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
SHOTEstimationBase | SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
SHOTEstimationOMP | SHOTEstimationOMP estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals, in parallel, using the OpenMP standard
SHOTLocalReferenceFrameEstimation | SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor
SHOTLocalReferenceFrameEstimationOMP | SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor
SIFTKeypoint | SIFTKeypoint detects the Scale Invariant Feature Transform keypoints for a given point cloud dataset containing points and intensity
SIFTKeypointFieldSelector |
SIFTKeypointFieldSelector< PointNormal > |
SIFTKeypointFieldSelector< PointXYZRGB > |
SIFTKeypointFieldSelector< PointXYZRGBA > |
SmoothedSurfacesKeypoint | 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
SolverDidntConvergeException | An exception that is thrown when the non linear solver didn't converge
SparseQuantizedMultiModTemplate | A multi-modality template constructed from a set of quantized multi-modality features
SpinImageEstimation | Estimates spin-image descriptors in the given input points
StaticRangeCoder | StaticRangeCoder compression class
StatisticalMultiscaleInterestRegionExtraction | Class for extracting interest regions from unstructured point clouds, based on a multi scale statistical approach
StatisticalOutlierRemoval | StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data
StatisticalOutlierRemoval< pcl::PCLPointCloud2 > | StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data
StatsEstimator | Class interface for gathering statistics for decision tree learning
StereoGrabber |
StereoGrabberBase | Base class for Stereo file grabber
StereoMatching | Stereo Matching abstract class
StopWatch | Simple stopwatch
Supervoxel | Supervoxel container class - stores a cluster extracted using supervoxel clustering
SupervoxelClustering | Implements a supervoxel algorithm based on voxel structure, normals, and rgb values
VoxelData | VoxelData is a structure used for storing data within a pcl::octree::OctreePointCloudAdjacencyContainer
SurfaceNormalModality | Modality based on surface normals
Candidate | Candidate for a feature (used in feature extraction methods)
SurfaceReconstruction | SurfaceReconstruction represents a base surface reconstruction class
SurfelSmoothing |
SUSANKeypoint | SUSANKeypoint implements a RGB-D extension of the SUSAN detector including normal directions variation in top of intensity variation
SVM | Base class for SVM SVM (Support Vector Machines)
SVMClassify | SVM (Support Vector Machines) classification of a dataset
SVMData | The structure stores the features and the label of a single sample which has to be used for the training or the classification of the SVM (Support Vector Machines)
SVMDataPoint | The structure initialize a single feature value for the classification using SVM (Support Vector Machines)
SVMModel | The structure initialize a model created by the SVM (Support Vector Machines) classifier (pcl::SVMTrain)
SVMParam | The structure stores the parameters for the classificationa nd must be initialized and passed to the training method pcl::SVMTrain
SVMTrain | SVM (Support Vector Machines) training class for the SVM machine learning
SynchronizedQueue |
Synchronizer | /brief This template class synchronizes two data streams of different types
TernaryTreeMissingDataBranchEstimator | Branch estimator for ternary trees where one branch is used for missing data (indicated by flag != 0)
TexMaterial |
RGB |
TextureMapping | The texture mapping algorithm
TextureMesh |
TfQuadraticXYZComparison | A comparison whether the (x,y,z) components of a given point satisfy (p'Ap + 2v'p + c [OP] 0)
TimeTrigger | Timer class that invokes registered callback methods periodically
TimGrabber |
TrajkovicKeypoint2D | TrajkovicKeypoint2D implements Trajkovic and Hedley corner detector on organized point cloud using intensity information
TrajkovicKeypoint3D | TrajkovicKeypoint3D implements Trajkovic and Hedley corner detector on point cloud using geometric information
TransformationFromCorrespondences | Calculates a transformation based on corresponding 3D points
TSDFVolume |
Header | Structure storing voxel grid resolution, volume size (in mm) and element_size of stored data
Intr | Camera intrinsics structure
UnaryClassifier |
UnhandledPointTypeException |
UniformSampling | UniformSampling assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
Leaf | Simple structure to hold an nD centroid and the number of points in a leaf
UniqueShapeContext | UniqueShapeContext implements the Unique Shape Context Descriptor described here:
UniqueShapeContext1960 | A point structure representing a Unique Shape Context
UnorganizedPointCloudException | An exception that is thrown when an organized point cloud is needed but not provided
VectorAverage | Calculates the weighted average and the covariance matrix
Vertices | Describes a set of vertices in a polygon mesh, by basically storing an array of indices
VFHEstimation | VFHEstimation estimates the Viewpoint Feature Histogram (VFH) descriptor for a given point cloud dataset containing points and normals
VFHSignature308 | A point structure representing the Viewpoint Feature Histogram (VFH)
VLPGrabber | Grabber for the Velodyne LiDAR (VLP), based on the Velodyne High Definition Laser (HDL)
VoxelGrid | VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
VoxelGrid< pcl::PCLPointCloud2 > | VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
VoxelGridCovariance | A searchable voxel structure containing the mean and covariance of the data
Leaf | Simple structure to hold a centroid, covarince and the number of points in a leaf
VoxelGridLabel |
VoxelGridOcclusionEstimation | VoxelGrid to estimate occluded space in the scene
VTKUtils |
vtkXRenderWindowInteractor |
xNdCopyEigenPointFunctor | Helper functor structure for copying data between an Eigen::VectorXf and a PointT
xNdCopyPointEigenFunctor | Helper functor structure for copying data between an Eigen::VectorXf and a PointT
pcl_cuda |
Filter | Removes points with x, y, or z equal to NaN
isFiniteAOS | Check if a specific point is valid or not
isFiniteSOA | Check if a specific point is valid or not
isFiniteZIPSOA | Check if a specific point is valid or not
MEstimatorSampleConsensus |
PassThrough | PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints
PassThrough< PointCloudAOS< Device > > |
PassThrough< PointCloudSOA< Device > > |
VoxelGrid | VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
VoxelGrid< PointCloudAOS< Device > > |
VoxelGrid< PointCloudSOA< Device > > |
Ui |