Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:

__pixAdd_CN< Tin, Tout, CN > |
__pixAdd_CN< Tin, Tout, 1 > |
__pixAdd_CN< Tin, Tout, 3 > |
__pixAdd_CN< Tin, Tout, 4 > |
__pixColorConv< CSin, CSout, Tin, Tout > |
__pixColorConv< NCVColorSpaceGray, NCVColorSpaceRGBA, Tin, Tout > |
__pixColorConv< NCVColorSpaceRGBA, NCVColorSpaceGray, Tin, Tout > |
__pixDemoteClampNN_CN< Tin, Tout, CN > |
__pixDemoteClampNN_CN< Tin, Tout, 1 > |
__pixDemoteClampNN_CN< Tin, Tout, 3 > |
__pixDemoteClampNN_CN< Tin, Tout, 4 > |
__pixDemoteClampZ_CN< Tin, Tout, CN > |
__pixDemoteClampZ_CN< Tin, Tout, 1 > |
__pixDemoteClampZ_CN< Tin, Tout, 3 > |
__pixDemoteClampZ_CN< Tin, Tout, 4 > |
__pixDist_CN< Tin, Tout, CN > |
__pixDist_CN< Tin, Tout, 1 > |
__pixDist_CN< Tin, Tout, 3 > |
__pixDist_CN< Tin, Tout, 4 > |
__pixScale_CN< Tin, Tout, Tw, CN > |
__pixScale_CN< Tin, Tout, Tw, 1 > |
__pixScale_CN< Tin, Tout, Tw, 3 > |
__pixScale_CN< Tin, Tout, Tw, 4 > |
pcl::_Axis |
pcl::Axis | A point structure representing an Axis using its normal coordinates
pcl::_Intensity |
pcl::Intensity | A point structure representing the grayscale intensity in single-channel images
pcl::_Intensity32u |
pcl::Intensity32u | A point structure representing the grayscale intensity in single-channel images
pcl::_Intensity8u |
pcl::Intensity8u | A point structure representing the grayscale intensity in single-channel images
pcl::_Normal |
pcl::Normal | A point structure representing normal coordinates and the surface curvature estimate
pcl::tracking::_ParticleXYR |
pcl::tracking::ParticleXYR |
pcl::tracking::_ParticleXYRP |
pcl::tracking::ParticleXYRP |
pcl::tracking::_ParticleXYRPY |
pcl::tracking::ParticleXYRPY |
pcl::tracking::_ParticleXYZR |
pcl::tracking::ParticleXYZR |
pcl::tracking::_ParticleXYZRPY |
pcl::tracking::ParticleXYZRPY |
pcl::_PointDEM |
pcl::PointDEM | A point structure representing Digital Elevation Map
pcl::_PointNormal |
pcl::PointNormal | A point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate
pcl::_PointSurfel |
pcl::PointSurfel | A surfel, that is, a point structure representing Euclidean xyz coordinates, together with normal coordinates, a RGBA color, a radius, a confidence value and the surface curvature estimate
pcl::_PointWithRange |
pcl::PointWithRange | A point structure representing Euclidean xyz coordinates, padded with an extra range float
pcl::_PointWithScale |
pcl::PointWithScale | A point structure representing a 3-D position and scale
pcl::_PointWithViewpoint |
pcl::PointWithViewpoint | A point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen
pcl::_PointXYZ |
pcl::PointXYZ | A point structure representing Euclidean xyz coordinates
pcl::_PointXYZHSV |
pcl::PointXYZHSV |
pcl::_PointXYZI | A point structure representing Euclidean xyz coordinates, and the intensity value
pcl::PointXYZI |
pcl::_PointXYZINormal |
pcl::PointXYZINormal | A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate
pcl::_PointXYZL |
pcl::PointXYZL |
pcl::_PointXYZLAB |
pcl::PointXYZLAB | A custom point type for position and CIELAB color value
pcl::_PointXYZLNormal |
pcl::PointXYZLNormal | A point structure representing Euclidean xyz coordinates, a label, together with normal coordinates and the surface curvature estimate
pcl::_PointXYZRGB |
pcl::PointXYZRGB | A point structure representing Euclidean xyz coordinates, and the RGB color
pcl::_PointXYZRGBA |
pcl::PointXYZRGBA | A point structure representing Euclidean xyz coordinates, and the RGBA color
pcl::_PointXYZRGBL |
pcl::PointXYZRGBL |
pcl::_PointXYZRGBNormal |
pcl::PointXYZRGBNormal | A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate
pcl::_ReferenceFrame | A structure representing the Local Reference Frame of a point
pcl::ReferenceFrame |
pcl::_RGB |
pcl::RGB | A structure representing RGB color information
pcl::keypoints::agast::AbstractAgastDetector | Abstract detector class for AGAST corner point detectors
pcl::keypoints::agast::AgastDetector5_8 | Detector class for AGAST corner point detector (5_8)
pcl::keypoints::agast::AgastDetector7_12s | Detector class for AGAST corner point detector (7_12s)
pcl::keypoints::agast::OastDetector9_16 | Detector class for AGAST corner point detector (OAST 9_16)
AbstractMetadata | Abstract interface for outofcore metadata file types
pcl::detail::AccumulatorCurvature |
pcl::detail::AccumulatorIntensity |
pcl::detail::AccumulatorLabel |
pcl::detail::AccumulatorNormal |
pcl::detail::AccumulatorRGBA |
pcl::detail::Accumulators< PointT > |
pcl::detail::Accumulators< pcl::PointXYZRGB > |
pcl::detail::AccumulatorXYZ |
pcl::AdaptiveRangeCoder | AdaptiveRangeCoder compression class
pcl::cuda::AddCovariances | Adds two matrices element-wise
pcl::detail::AddPoint< PointT > |
pcl::cuda::AddPoints | Simple kernel to add two points
pcl::keypoints::internal::AgastApplyNonMaxSuppresion< Out > |
pcl::keypoints::internal::AgastApplyNonMaxSuppresion< pcl::PointUV > |
pcl::keypoints::internal::AgastDetector< Out > |
pcl::keypoints::internal::AgastDetector< pcl::PointUV > |
pcl::poisson::Allocator< T > | 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
pcl::poisson::Allocator< pcl::poisson::MatrixEntry< T > > |
pcl::poisson::Allocator< pcl::poisson::OctNode > |
pcl::poisson::AllocatorState |
and_ |
pcl::detail::IsAccumulatorCompatible< Point1T, Point2T >::apply< AccumulatorT > |
pcl::visualization::AreaPickingEvent | /brief Class representing 3D area picking events
array |
pcl::gpu::people::trees::Histogram |
pcl::FastBilateralFilter< PointT >::Array3D |
pcl::traits::asEnum< T > |
pcl::traits::asEnum< double > |
pcl::traits::asEnum< float > |
pcl::traits::asEnum< std::int16_t > |
pcl::traits::asEnum< std::int32_t > |
pcl::traits::asEnum< std::int8_t > |
pcl::traits::asEnum< std::uint16_t > |
pcl::traits::asEnum< std::uint32_t > |
pcl::traits::asEnum< std::uint8_t > |
NcvCTprep::assertTest< x > |
pcl::traits::asType< int > |
pcl::traits::asType< pcl::PCLPointField::FLOAT32 > |
pcl::traits::asType< pcl::PCLPointField::FLOAT64 > |
pcl::traits::asType< pcl::PCLPointField::INT16 > |
pcl::traits::asType< pcl::PCLPointField::INT32 > |
pcl::traits::asType< pcl::PCLPointField::INT8 > |
pcl::traits::asType< pcl::PCLPointField::UINT16 > |
pcl::traits::asType< pcl::PCLPointField::UINT32 > |
pcl::traits::asType< pcl::PCLPointField::UINT8 > |
pcl::gpu::AsyncCopy< T > |
pcl::gpu::people::trees::AttribLocation |
BFGS< FunctorType > | BFGS stands for Broyden–Fletcher–Goldfarb–Shanno (BFGS) method for solving unconstrained nonlinear optimization problems
BFGSDummyFunctor< _Scalar, NX > |
BFGSDummyFunctor< double, 6 > |
pcl::GeneralizedIterativeClosestPoint< PointSource, PointTarget >::OptimizationFunctorWithIndices | Optimization functor structure
pcl::poisson::BinaryNode< Real > |
pcl::BivariatePolynomialT< real > | This represents a bivariate polynomial and provides some functionality for it
pcl::gpu::people::Blob2 | This structure contains all parameters to describe blobs and their parent/child relations
pcl::device::Block |
pcl::device::kinfuLS::Block |
pcl::BorderDescription | A structure to store if a point in a range image lies on a border between an obstacle and the background
pcl::Boundary | A point structure representing a description of whether a point is lying on a surface boundary or not
pcl::recognition::BVH< UserData >::BoundedObject |
pcl::BoundingBoxXYZ |
pcl::segmentation::grabcut::BoykovKolmogorov | Boost implementation of Boykov and Kolmogorov's maxflow algorithm doesn't support negative flows which makes it inappropriate for this context
pcl::BranchEstimator | Interface for branch estimators
pcl::BinaryTreeThresholdBasedBranchEstimator | Branch estimator for binary trees where the branch is computed only from the threshold
pcl::TernaryTreeMissingDataBranchEstimator | Branch estimator for ternary trees where one branch is used for missing data (indicated by flag != 0)
pcl::BRISK2DEstimation< PointInT, PointOutT, KeypointT, IntensityT > | Implementation of the BRISK-descriptor, based on the original code and paper reference by
pcl::BRISKSignature512 | A point structure representing the Binary Robust Invariant Scalable Keypoints (BRISK)
pcl::poisson::BSplineData< Degree, Real >::BSplineComponents |
pcl::poisson::BSplineData< Degree, Real > |
pcl::poisson::BSplineData< Degree, BSplineDataReal > |
pcl::poisson::BSplineElementCoefficients< Degree > |
pcl::io::Buffer< T > | An abstract base class for fixed-size data buffers
pcl::io::AverageBuffer< T > | A buffer that computes running window average of the data inserted
pcl::io::MedianBuffer< T > | A buffer that computes running window median of the data inserted
pcl::io::SingleBuffer< T > | A simple buffer that only stores data
buffer_traits< T > |
buffer_traits< double > |
buffer_traits< float > |
pcl::recognition::BVH< UserData > | This class is an implementation of bounding volume hierarchies
pcl::registration::by_score | Sorting of candidates based on fitness score value
pcl::device::CalcMorton |
pcl::texture_mapping::Camera | Structure to store camera pose and focal length
pcl::visualization::Camera | Camera class holds a set of camera parameters together with the window pos/size
pcl::io::CameraParameters | Basic camera parameters placeholder
CameraPoseProcessor | Interface to extract camera pose data generated by the pcl_kinfu_app program
CameraPoseWriter | CameraPoseWriter writes all camera poses computed by the KinfuTracker to a file on disk
pcl::ColorGradientDOTModality< PointInT >::Candidate |
pcl::ColorGradientModality< PointInT >::Candidate | Candidate for a feature (used in feature extraction methods)
pcl::ColorModality< PointInT >::Candidate |
pcl::SurfaceNormalModality< PointInT >::Candidate | Candidate for a feature (used in feature extraction methods)
pcl::gpu::CaptureOpenNI |
pcl::gpu::kinfuLS::CaptureOpenNI |
pcl::CentroidPoint< PointT > | A generic class that computes the centroid of points fed to it
pcl::cuda::ChangeColor |
pcl::cuda::CheckPlanarInlier | Check if a certain tuple is a point inlier
pcl::cuda::CheckPlanarInlierIndices | Check if a certain tuple is a point inlier
pcl::cuda::CheckPlanarInlierKinectIndices | Check if a certain tuple is a point inlier
pcl::cuda::CheckPlanarInlierKinectNormalIndices | Check if a certain tuple is a point inlier
pcl::cuda::CheckPlanarInlierNormalIndices | Check if a certain tuple is a point inlier
cJSON |
cJSON_Hooks |
pcl::Clipper3D< PointT > | Base class for 3D clipper objects
pcl::BoxClipper3D< PointT > | Implementation of a box clipper in 3D. Actually it allows affine transformations, thus any parallelepiped in general pose. The affine transformation is used to transform the point before clipping it using the unit cube centered at origin and with an extend of -1 to +1 in each dimension
pcl::PlaneClipper3D< PointT > | Implementation of a plane clipper in 3D
cloud_point_index_idx |
pcl::visualization::CloudActor |
pcl::common::CloudGenerator< PointT, GeneratorT > |
pcl::common::CloudGenerator< pcl::PointXY, GeneratorT > |
pcl::CloudIterator< PointT > | Iterator class for point clouds with or without given indices
code |
pcl::segmentation::grabcut::Color | Structure to save RGB colors into floats
pcl::octree::ColorCoding< PointT > | ColorCoding class
pcl::octree::ColorCoding< pcl::PointXYZRGB > |
pcl::ColorLUT< T > |
pcl::gpu::ColorVolume | ColorVolume class
pcl::gpu::kinfuLS::ColorVolume | ColorVolume class
pcl::keypoints::brisk::Layer::CommonParams |
pcl::Comparator< PointT > | Comparator is the base class for comparators that compare two points given some function
pcl::experimental::EuclideanClusterComparator< PointT, PointLT > |
pcl::EuclideanClusterComparator< PointT, PointNT, PointLT > | EuclideanClusterComparator is a comparator used for finding clusters based on euclidian distance
pcl::EuclideanClusterComparator< PointT, PointLT, deprecated::T > |
pcl::GroundPlaneComparator< PointT, PointNT > | GroundPlaneComparator is a Comparator for detecting smooth surfaces suitable for driving
pcl::PlaneCoefficientComparator< PointT, PointNT > | PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
pcl::EdgeAwarePlaneComparator< PointT, PointNT > | EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
pcl::EuclideanPlaneCoefficientComparator< PointT, PointNT > | EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
pcl::PlaneRefinementComparator< PointT, PointNT, PointLT > | PlaneRefinementComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
pcl::RGBPlaneCoefficientComparator< PointT, PointNT > | RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation
pcl::device::CompareByLevelCode |
pcl::SupervoxelClustering< PointT >::SupervoxelHelper::compareLeaves | Comparator for LeafContainerT pointers - used for sorting set of leaves
pcl::keypoints::agast::AbstractAgastDetector::CompareScoreIndex | Score index comparator
pcl::ComparisonBase< PointT > | The (abstract) base class for the comparison object
pcl::FieldComparison< PointT > | The field-based specialization of the comparison object
pcl::PackedHSIComparison< PointT > | A packed HSI specialization of the comparison object
pcl::PackedRGBComparison< PointT > | A packed rgb specialization of the comparison object
pcl::TfQuadraticXYZComparison< PointT > | A comparison whether the (x,y,z) components of a given point satisfy (p'Ap + 2v'p + c [OP] 0)
pcl::io::CompressionPointTraits< PointT > |
pcl::io::CompressionPointTraits< PointXYZRGB > |
pcl::io::CompressionPointTraits< PointXYZRGBA > |
pcl::cuda::ComputeCovarianceForPoint | Kernel to compute a `‘covariance matrix’' for a single point
pcl::cuda::ComputeXYZ | Compute the XYZ values for a point based on disparity information
pcl::cuda::ComputeXYZRGB | Compute the XYZ and RGB values for a point based on disparity information
pcl::ConditionBase< PointT > | Base condition class
pcl::ConditionAnd< PointT > | AND condition
pcl::ConditionOr< PointT > | OR condition
pcl::io::configurationProfile_t |
pcl::device::ConnectedComponents |
pcl::ConstCloudIterator< PointT > | Iterator class for point clouds with or without given indices
pcl::ConstCloudIterator< PointT >::ConstIteratorIdx |
pcl::poisson::OctNode< NodeData, Real >::ConstNeighborKey3 |
pcl::poisson::OctNode< NodeData, Real >::ConstNeighborKey5 |
pcl::poisson::OctNode< NodeData, Real >::ConstNeighbors3 |
pcl::poisson::OctNode< NodeData, Real >::ConstNeighbors5 |
boost::container_gen< eigen_listS, ValueType > |
boost::container_gen< eigen_vecS, ValueType > |
pcl::registration::ConvergenceCriteria | ConvergenceCriteria represents an abstract base class for different convergence criteria used in registration loops
pcl::registration::DefaultConvergenceCriteria< float > |
pcl::registration::DefaultConvergenceCriteria< Scalar > | DefaultConvergenceCriteria represents an instantiation of ConvergenceCriteria, and implements the following criteria for registration loop evaluation:
pcl::cuda::convert_point_to_float3 | Simple kernel to convert a PointXYZRGB to float3
pcl::filters::Convolution< PointIn, PointOut > | 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
pcl::filters::ConvolvingKernel< PointInT, PointOutT > | Class ConvolvingKernel base class for all convolving kernels
pcl::filters::GaussianKernel< PointInT, PointOutT > | Gaussian kernel implementation interface Use this as implementation reference
pcl::filters::GaussianKernelRGB< PointInT, PointOutT > | Gaussian kernel implementation interface with RGB channel handling Use this as implementation reference
pcl::filters::ConvolvingKernel< PointT, pcl::Normal > |
pcl::filters::ConvolvingKernel< PointT, pcl::PointXY > |
DataGenerator::ConvPoint< Dst > |
pcl::CopyIfFieldExists< PointInT, OutT > | A helper functor that can copy a specific value if the given field exists
pcl::detail::CopyPointHelper< PointInT, PointOutT, Enable > |

pcl::detail::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 > >

pcl::detail::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 > >

pcl::detail::CopyPointHelper< PointInT, PointOutT, std::enable_if_t< std::is_same< PointInT, PointOutT >::value > > |
pcl::poisson::CoredEdgeIndex |
pcl::poisson::CoredMeshData |
pcl::poisson::CoredFileMeshData |
pcl::poisson::CoredVectorMeshData |
pcl::poisson::CoredMeshData2 |
pcl::poisson::CoredFileMeshData2 |
pcl::poisson::CoredVectorMeshData2 |
pcl::poisson::CoredPointIndex |
pcl::poisson::CoredVertexIndex |
pcl::poisson::SortedTreeNodes::CornerIndices |
pcl::poisson::SortedTreeNodes::CornerTableData |
pcl::Correspondence | Correspondence represents a match between two entities (e.g., points, descriptors, etc)
pcl::PointCorrespondence3D | Representation of a (possible) correspondence between two 3D points in two different coordinate frames (e.g
pcl::PointCorrespondence6D | Representation of a (possible) correspondence between two points (e.g
pcl::registration::CorrespondenceRejector | CorrespondenceRejector represents the base class for correspondence rejection methods
pcl::registration::CorrespondenceRejectionOrganizedBoundary | Implements a simple correspondence rejection measure
pcl::registration::CorrespondenceRejectorDistance | CorrespondenceRejectorDistance implements a simple correspondence rejection method based on thresholding the distances between the correspondences
pcl::registration::CorrespondenceRejectorFeatures | CorrespondenceRejectorFeatures implements a correspondence rejection method based on a set of feature descriptors
pcl::registration::CorrespondenceRejectorMedianDistance | CorrespondenceRejectorMedianDistance implements a simple correspondence rejection method based on thresholding based on the median distance between the correspondences
pcl::registration::CorrespondenceRejectorOneToOne | CorrespondenceRejectorOneToOne implements a correspondence rejection method based on eliminating duplicate match indices in the correspondences
pcl::registration::CorrespondenceRejectorPoly< SourceT, TargetT > | 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
pcl::registration::CorrespondenceRejectorSampleConsensus< PointT > | CorrespondenceRejectorSampleConsensus implements a correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers)
pcl::registration::CorrespondenceRejectorSampleConsensus2D< PointT > | CorrespondenceRejectorSampleConsensus2D implements a pixel-based correspondence rejection using Random Sample Consensus to identify inliers (and reject outliers)
pcl::registration::CorrespondenceRejectorSurfaceNormal | CorrespondenceRejectorSurfaceNormal implements a simple correspondence rejection method based on the angle between the normals at correspondent points
pcl::registration::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
pcl::registration::CorrespondenceRejectorVarTrimmed | CorrespondenceRejectoVarTrimmed implements a simple correspondence rejection method by considering as inliers a certain percentage of correspondences with the least distances
pcl::cuda::CountPlanarInlier | Check if a certain tuple is a point inlier
pcl::cuda::CovarianceMatrix | Misnamed class holding a 3x3 matrix
pcl::CPPFSignature | A point structure for storing the Point Pair Feature (CPPF) values
pcl::cuda::Create1PointPlaneHypothesis< Storage > | Check if a certain tuple is a point inlier
pcl::cuda::Create1PointPlaneSampleHypothesis< Storage > | Check if a certain tuple is a point inlier
pcl::cuda::CreatePlaneHypothesis< Storage > | Check if a certain tuple is a point inlier
pcl::CrfNormalSegmentation< PointT > |
pcl::CrfSegmentation< PointT > |
pcl::CRHAlignment< PointT, nbins_ > | CRHAlignment uses two Camera Roll Histograms (CRH) to find the roll rotation that aligns both views
NcvCTprep::CT_ASSERT_FAILURE< x > |
NcvCTprep::CT_ASSERT_FAILURE< true > |
ct_data_s |
pcl::poisson::Cube |
pcl::device::CUDATree | Struct that holds a single RDF tree in GPU
pcl::gpu::kinfuLS::CyclicalBuffer | CyclicalBuffer implements a cyclical TSDF buffer
pcl::recognition::ORROctree::Node::Data |
pcl::registration::DataContainerInterface | DataContainerInterface provides a generic interface for computing correspondence scores between correspondent points in the input and target clouds
pcl::registration::DataContainer< PointT, NormalT > | 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
DataGenerator |
pcl::gpu::DataSource |
pcl::traits::datatype< PointT, Tag > |
pcl::io::DeBayer | Various debayering methods
pcl::cuda::DebayerBilinear< Storage > |
pcl::cuda::Debayering< Storage > |
pcl::cuda::DebayeringDownsampling< Storage > |
pcl::DecisionForestEvaluator< FeatureType, DataSet, LabelType, ExampleIndex, NodeType > | Utility class for evaluating a decision forests
pcl::DecisionForestTrainer< FeatureType, DataSet, LabelType, ExampleIndex, NodeType > | Trainer for decision trees
pcl::DecisionTree< NodeType > | Class representing a decision tree
pcl::DecisionTreeEvaluator< FeatureType, DataSet, LabelType, ExampleIndex, NodeType > | Utility class for evaluating a decision tree
pcl::DecisionTreeTrainer< FeatureType, DataSet, LabelType, ExampleIndex, NodeType > | Trainer for decision trees
pcl::DecisionTreeTrainerDataProvider< FeatureType, DataSet, LabelType, ExampleIndex, NodeType > |
pcl::face_detection::FaceDetectorDataProvider< FeatureType, DataSet, LabelType, ExampleIndex, NodeType > |
pcl::traits::decomposeArray< T > |
pcl::ConstCloudIterator< PointT >::DefaultConstIterator |
pcl::DefaultIterator< PointT > |
pcl::geometry::DefaultMeshTraits< VertexDataT, HalfEdgeDataT, EdgeDataT, FaceDataT > | The mesh traits are used to set up compile time settings for the mesh
pcl::cuda::DeleteIndices | Check if a certain tuple is a point inlier
pcl::DenseCrf |
pcl::DenseQuantizedMultiModTemplate |
pcl::DenseQuantizedSingleModTemplate |
DeprecatedType | A dummy type to aid in template parameter deprecation
pcl::io::DepthImage | This class provides methods to fill a depth or disparity image
openni_wrapper::DepthImage | This class provides methods to fill a depth or disparity image
pcl::io::depth_sense::DepthSenseGrabberImpl |
pcl::LineRGBD< PointXYZT, PointRGBT >::Detection | A LineRGBD detection
pcl::cuda::Device< T > | Device helper class
openni_wrapper::OpenNIDriver::DeviceContext |
pcl::gpu::DeviceMemory | DeviceMemory class
pcl::gpu::DeviceArray< curandState > |
pcl::gpu::DeviceArray< double > |
pcl::gpu::DeviceArray< float > |
pcl::gpu::DeviceArray< float4 > |
pcl::gpu::DeviceArray< int > |
pcl::gpu::DeviceArray< Label > |
pcl::gpu::DeviceArray< NormalType > |
pcl::gpu::DeviceArray< pcl::gpu::people::trees::Node > |
pcl::gpu::DeviceArray< pcl::PointXYZ > |
pcl::gpu::DeviceArray< pcl::tracking::ParticleXYZRPY > |
pcl::gpu::DeviceArray< PointType > |
pcl::gpu::DeviceArray< std::uint64_t > |
pcl::gpu::DeviceArray< unsigned char > |
pcl::gpu::DeviceArray< T > | DeviceArray class
pcl::gpu::DeviceMemory2D | DeviceMemory2D class
pcl::gpu::DeviceArray2D< char4 > |
pcl::gpu::DeviceArray2D< double > |
pcl::gpu::DeviceArray2D< float > |
pcl::gpu::DeviceArray2D< int > |
pcl::gpu::DeviceArray2D< pcl::FPFHSignature33 > |
pcl::gpu::DeviceArray2D< pcl::PointXYZ > |
pcl::gpu::DeviceArray2D< pcl::RGB > |
pcl::gpu::DeviceArray2D< prob_histogram > |
pcl::gpu::DeviceArray2D< unsigned char > |
pcl::gpu::DeviceArray2D< unsigned short > |
pcl::gpu::DeviceArray2D< T > | DeviceArray2D class
pcl::gpu::DevPtr< T > |
pcl::gpu::PtrStep< T > |
pcl::gpu::PtrStepSz< T > |
pcl::gpu::PtrSz< T > |
pcl::device::Dilatation |
pcl::cuda::DisparityBoundSmoothing |
pcl::cuda::DisparityClampedSmoothing |
pcl::cuda::DisparityHelperMap |
pcl::DisparityMapConverter< PointT > | Compute point cloud from the disparity map
pcl::DisparityMapConverter< PointDEM > |
pcl::DigitalElevationMapBuilder | Build a Digital Elevation Map in the column-disparity space from a disparity map and a color image of the scene
pcl::cuda::DisparityToCloud | Disparity to PointCloudAOS generator
pcl::DistanceMap | Represents a distance map obtained from a distance transformation
pcl::cuda::detail::DjSets |
pcl::DOTMOD | Template matching using the DOTMOD approach
pcl::DOTModality |
pcl::ColorGradientDOTModality< PointInT > |
pcl::DOTMODDetection |
pcl::cuda::downsampleIndices |
pcl::Edge< PointInT, PointOutT > |
pcl::poisson::Edge |
pcl::poisson::EdgeIndex |
pcl::poisson::SortedTreeNodes::EdgeIndices |
pcl::registration::LUM< PointT >::EdgeProperties |
pcl::poisson::SortedTreeNodes::EdgeTableData |
pcl::device::Eigen33 |
pcl::device::kinfuLS::Eigen33 |
boost::eigen_listS |
boost::eigen_vecS |
pcl::detail::EigenVector< Vector, Scalar > |
pcl::device::Emulation |
pcl::device::kinfuLS::Emulation |
pcl::EnergyMaps | Stores a set of energy maps
pcl::recognition::RotationSpaceCell::Entry |
pcl::search::OrganizedNeighbor< PointT >::Entry |
equality_comparable |
pcl::geometry::FaceAroundFaceCirculator< MeshT > | Circulates clockwise around a face and returns an index to the face of the outer half-edge (the target)
pcl::geometry::FaceAroundVertexCirculator< MeshT > | Circulates counter-clockwise around a vertex and returns an index to the face of the outgoing half-edge (the target)
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< MeshT > | Circulates counter-clockwise around a vertex and returns an index to the incoming half-edge (the target)
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< MeshT > | Circulates clockwise around a face and returns an index to the inner half-edge (the target)
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< MeshT > | Circulates clockwise around a face and returns an index to the outer half-edge (the target)
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< MeshT > | Circulates counter-clockwise around a vertex and returns an index to the outgoing half-edge (the target)
pcl::geometry::VertexAroundFaceCirculator< MeshT > | Circulates clockwise around a face and returns an index to the terminating vertex of the inner half-edge (the target)
pcl::geometry::VertexAroundVertexCirculator< MeshT > | Circulates counter-clockwise around a vertex and returns an index to the terminating vertex of the outgoing half-edge (the target)
pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::ErrorFunctor |
pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::HuberPenalty |
pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::TruncatedError |
pcl::ESFSignature640 | A point structure representing the Ensemble of Shape Functions (ESF)
pcl::gpu::EuclideanClusterExtraction | EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, depending on pcl::gpu::octree
pcl::gpu::EuclideanLabeledClusterExtraction< PointT > | EuclideanLabeledClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, depending on pcl::gpu::octree
Evaluation | Class for RGB-D SLAM Dataset and Benchmark
pcl::EventFrequency | A helper class to measure frequency of a certain event
exception |
openni_wrapper::OpenNIException | General exception class
pcl::io::IOException | General IO exception class
pcl::geometry::Face | A face is a closed loop of edges
pcl::gpu::people::FaceDetector |
pcl::device::FacetStream |
pcl::cuda::FastNormalEstimationKernel< Storage > |
pcl::gpu::Feature | Feature represents the base feature class
pcl::gpu::FeatureFromNormals | Feature represents the base feature class that takes normals as input also
pcl::gpu::FPFHEstimation | Class for FPFH estimation
pcl::gpu::PFHEstimation | Class for PFH estimation
pcl::gpu::PFHRGBEstimation | Class for PFHRGB estimation
pcl::gpu::PPFEstimation | **
pcl::gpu::PPFRGBEstimation | **
pcl::gpu::PPFRGBRegionEstimation | **
pcl::gpu::VFHEstimation | Class for PPFRGBRegion estimation
pcl::gpu::NormalEstimation | Class for normal estimation
pcl::registration::CorrespondenceRejectorFeatures::FeatureContainerInterface |
pcl::registration::CorrespondenceRejectorFeatures::FeatureContainer< FeatureT > | An inner class containing pointers to the source and target feature clouds and the parameters needed to perform the correspondence search
pcl::FeatureHandler< FeatureType, DataSet, ExampleIndex > | Utility class interface which is used for creating and evaluating features
pcl::FeatureHandler< FT, DataSet, ExampleIndex > |
pcl::face_detection::FeatureHandlerDepthAverage< FT, DataSet, ExampleIndex > |
pcl::FeatureHandler< pcl::MultiChannel2DComparisonFeature< pcl::PointXY32f >, pcl::MultiChannel2DDataSet< DATA_TYPE, NUM_OF_CHANNELS >, pcl::MultipleData2DExampleIndex > |
pcl::ScaledMultiChannel2DComparisonFeatureHandler< DATA_TYPE, NUM_OF_CHANNELS, SCALE_CHANNEL, INVERT_SCALE > | Feature utility class that handles the creation and evaluation of RGBD comparison features
pcl::FeatureHandler< pcl::MultiChannel2DComparisonFeature< pcl::PointXY32i >, pcl::MultiChannel2DDataSet< DATA_TYPE, NUM_OF_CHANNELS >, pcl::MultipleData2DExampleIndex > |
pcl::MultiChannel2DComparisonFeatureHandler< DATA_TYPE, NUM_OF_CHANNELS > | Feature utility class that handles the creation and evaluation of RGBD comparison features
FeatureHandlerCodeGenerator |
pcl::ScaledMultiChannel2DComparisonFeatureHandlerCCodeGenerator< DATA_TYPE, NUM_OF_CHANNELS, SCALE_CHANNEL, INVERT_SCALE > |
pcl::FeatureHistogram | Type for histograms for computing mean and variance of some floats
pcl::face_detection::FeatureType |
pcl::FeatureWithLocalReferenceFrames< PointInT, PointRFT > | FeatureWithLocalReferenceFrames provides a public interface for descriptor extractor classes which need a local reference frame at each input keypoint
pcl::SHOTEstimationBase< PointInT, PointNT, PointOutT, PointRFT > | SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
pcl::SHOTColorEstimation< PointInT, PointNT, PointOutT, PointRFT > | SHOTColorEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points, normals and colors
pcl::SHOTColorEstimationOMP< PointInT, PointNT, PointOutT, PointRFT > | 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
pcl::SHOTEstimation< PointInT, PointNT, PointOutT, PointRFT > | SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
pcl::SHOTEstimationOMP< PointInT, PointNT, PointOutT, PointRFT > | 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
pcl::UniqueShapeContext< PointInT, PointOutT, PointRFT > | UniqueShapeContext implements the Unique Shape Context Descriptor described here:
pcl::Fern< FeatureType, NodeType > | Class representing a Fern
pcl::FernEvaluator< FeatureType, DataSet, LabelType, ExampleIndex, NodeType > | Utility class for evaluating a fern
pcl::FernTrainer< FeatureType, DataSet, LabelType, ExampleIndex, NodeType > | Trainer for a Fern
pcl::detail::FieldAdder< PointT > |
pcl::traits::fieldList< PointT > |
pcl::detail::FieldMapper< PointT > |
pcl::detail::FieldMapping |
pcl::FieldMatches< PointT, Tag > |
pcl::visualization::Figure2D | Abstract class for storing figure information
pcl::visualization::FEllipticArc2D | Class for storing EllipticArc; every ellipse , circle are covered by this
pcl::visualization::FPoints2D | Class for storing Points
pcl::visualization::FPolygon2D | Class for Polygon
pcl::visualization::FPolyLine2D | Class for PolyLine
pcl::visualization::FQuad2D | Class for storing Quads
pcl::FileGrabber< PointT > | FileGrabber provides a container-style interface for grabbers which operate on fixed-size input
pcl::ImageGrabber< PointT > |
pcl::PCDGrabber< PointT > |
pcl::FileReader | Point Cloud Data (FILE) file format reader interface
pcl::ASCIIReader | Ascii Point Cloud Reader
pcl::OBJReader |
pcl::PCDReader | Point Cloud Data (PCD) file format reader
pcl::PLYReader | Point Cloud Data (PLY) file format reader
pcl::FileWriter | Point Cloud Data (FILE) file format writer
pcl::PCDWriter | Point Cloud Data (PCD) file format writer
pcl::PLYWriter | Point Cloud Data (PLY) file format writer
pcl::search::FlannSearch< PointT, FlannDistance >::FlannIndexCreator | Helper class that creates a FLANN index from a given FLANN matrix
pcl::search::FlannSearch< PointT, FlannDistance >::KdTreeIndexCreator | Creates a FLANN KdTreeSingleIndex from the given input data
pcl::search::FlannSearch< PointT, FlannDistance >::KdTreeMultiIndexCreator | Creates a FLANN KdTreeIndex of multiple randomized trees from the given input data, suitable for feature matching
pcl::search::FlannSearch< PointT, FlannDistance >::KMeansIndexCreator | Creates a FLANN KdTreeSingleIndex from the given input data
pcl::device::float12 |
pcl::device::kinfuLS::float12 |
pcl::device::float8 |
pcl::device::kinfuLS::float8 |
pcl::visualization::FloatImageUtils | Provide some gerneral functionalities regarding 2d float arrays, e.g., for visualization purposes
pcl::for_each_type_impl< done > |
pcl::for_each_type_impl< false > |
pcl::FPFHSignature33 | A point structure representing the Fast Point Feature Histogram (FPFH)
pcl::io::FrameWrapper | Pure abstract interface to wrap native frame data types
pcl::poisson::FunctionData< Degree, Real > |
pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar >::Functor< _Scalar, NX, NY > | 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
pcl::registration::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar >::Functor< _Scalar, NX, NY > | 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
pcl::Functor< _Scalar, NX, NY > | 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
pcl::Functor< double > |
pcl::Functor< float > |
pcl::registration::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar >::Functor< MatScalar > |
pcl::registration::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar >::OptimizationFunctor |
pcl::registration::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar >::OptimizationFunctorWithIndices |
pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar >::Functor< MatScalar > |
pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar >::OptimizationFunctor |
pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar >::OptimizationFunctorWithIndices |
functorAddValues< T > |
functorMaxValues< T > |
functorMinValues< T > |
pcl::GASDSignature512 | A point structure representing the Globally Aligned Spatial Distribution (GASD) shape descriptor
pcl::GASDSignature7992 | A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor
pcl::GASDSignature984 | A point structure representing the Globally Aligned Spatial Distribution (GASD) shape and color descriptor
pcl::segmentation::grabcut::Gaussian | Gaussian structure
pcl::segmentation::grabcut::GaussianFitter | Helper class that fits a single Gaussian to color samples
pcl::GaussianKernel | Class GaussianKernel assembles all the method for computing, convolving, smoothing, gradients computing an image using a gaussian kernel
pcl::detail::GetPoint< PointT > |
pcl::GFPFHSignature16 | A point structure representing the GFPFH descriptor with 16 bins
pcl::segmentation::grabcut::GMM |
pcl::Grabber | Grabber interface for PCL 1.x device drivers
pcl::DavidSDKGrabber | Grabber for davidSDK structured light compliant devices
pcl::DepthSenseGrabber | Grabber for DepthSense devices (e.g
pcl::DinastGrabber | Grabber for DINAST devices (i.e., IPA-1002, IPA-1110, IPA-2001)
pcl::EnsensoGrabber | Grabber for IDS-Imaging Ensenso's devices
pcl::HDLGrabber | Grabber for the Velodyne High-Definition-Laser (HDL)
pcl::VLPGrabber | Grabber for the Velodyne LiDAR (VLP), based on the Velodyne High Definition Laser (HDL)
pcl::ImageGrabberBase | Base class for Image file grabber
pcl::ImageGrabber< PointT > |
pcl::ONIGrabber | A simple ONI grabber
pcl::OpenNIGrabber | Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
pcl::PCDGrabberBase | Base class for PCD file grabber
pcl::PCDGrabber< PointT > |
pcl::RealSense2Grabber | Grabber for Intel Realsense 2 SDK devices (D400 series)
pcl::RealSenseGrabber |
pcl::RobotEyeGrabber | Grabber for the Ocular Robotics RobotEye sensor
pcl::StereoGrabberBase | Base class for Stereo file grabber
pcl::StereoGrabber< PointT > |
pcl::GradientXY | A point structure representing Euclidean xyz coordinates, and the intensity value
pcl::cuda::detail::Graph< T > |
pcl::cuda::detail::GraphEdge< T > |
pcl::registration::GraphHandler< GraphT > | GraphHandler class is a wrapper for a general SLAM graph The actual graph class must fulfill the following boost::graph concepts:
pcl::registration::GraphOptimizer< GraphT > | GraphOptimizer class; derive and specialize for each graph type
pcl::GraphRegistration< GraphT > | GraphRegistration class is the base class for graph-based registration methods
pcl::PairwiseGraphRegistration< GraphT, PointT > | PairwiseGraphRegistration class aligns the clouds two by two
pcl::people::GroundBasedPeopleDetectionApp< PointT > | GroundBasedPeopleDetectionApp performs people detection on RGB-D data having as input the ground plane coefficients
pcl::GRSDSignature21 | A point structure representing the Global Radius-based Surface Descriptor (GRSD)
gz_header_s |
HaarClassifierCascadeDescriptor | Classifier cascade descriptor
HaarClassifierNode128 |
HaarClassifierNodeDescriptor32 |
HaarFeature64 |
HaarFeatureDescriptor32 |
HaarStage64 |
pcl::geometry::HalfEdge | An edge is a connection between two vertices
pcl::has_custom_allocator< T > | Tests at compile time if type T has a custom allocator
pcl::HashTableOLD |
pcl::HDLGrabber::HDLDataPacket |
pcl::HDLGrabber::HDLFiringData |
pcl::HDLGrabber::HDLLaserCorrection |
pcl::HDLGrabber::HDLLaserReturn |
pcl::people::HeadBasedSubclustering< PointT > | HeadBasedSubclustering represents a class for searching for people inside a HeightMap2D based on a 3D head detection algorithm
pcl::TSDFVolume< VoxelT, WeightT >::Header | Structure storing voxel grid resolution, volume size (in mm) and element_size of stored data
pcl::gpu::kinfuLS::TsdfVolume::Header | Structure storing voxel grid resolution, volume size (in mm) and element_size of data stored on host
pcl::people::HeightMap2D< PointT > | HeightMap2D represents a class for creating a 2D height map from a point cloud and searching for its local maxima
pcl::DefaultFeatureRepresentation< PointDefault >::NdCopyPointFunctor::Helper< Key, FieldT, NrDims > |
pcl::DefaultFeatureRepresentation< PointDefault >::NdCopyPointFunctor::Helper< Key, FieldT[NrDims], NrDims > |
pcl::device::Histogram< N > |
pcl::Histogram< N > | A point structure representing an N-D histogram
pcl::gpu::people::trees::HistogramPair |
pcl::people::HOG | HOG represents a class for computing the HOG descriptor described in Dalal, N
pcl::cuda::Host< T > | Host helper class
pcl::recognition::HoughSpace3D | HoughSpace3D is a 3D voting space
pcl::recognition::HypothesisBase |
pcl::recognition::Hypothesis |
pcl::recognition::ObjRecRANSAC::HypothesisCreator |
pcl::HypothesisVerification< ModelT, SceneT > | Abstract class for hypotheses verification methods
pcl::GlobalHypothesesVerification< ModelT, SceneT > | A hypothesis verification method proposed in "A Global Hypotheses Verification Method for 3D Object Recognition", A
pcl::GreedyVerification< ModelT, SceneT > | A greedy hypothesis verification method
pcl::PapazovHV< ModelT, SceneT > | A hypothesis verification method proposed in "An Efficient RANSAC for 3D Object Recognition in Noisy and Occluded Scenes", C
pcl::IFSReader | Indexed Face set (IFS) file format reader
pcl::IFSWriter | Point Cloud Data (IFS) file format writer
pcl::io::Image | Image interface class providing an interface to fill a RGB or Grayscale image buffer
pcl::io::ImageRGB24 | This class provides methods to fill a RGB or Grayscale image buffer from underlying RGB24 image
pcl::io::ImageYUV422 | Concrete implementation of the interface Image for a YUV 422 image used by Primesense devices
openni_wrapper::Image | Image class containing just a reference to image meta data
openni_wrapper::ImageBayerGRBG | This class provides methods to fill a RGB or Grayscale image buffer from underlying Bayer pattern image
openni_wrapper::ImageRGB24 | This class provides methods to fill a RGB or Grayscale image buffer from underlying RGB24 image
openni_wrapper::ImageYUV422 | Concrete implementation of the interface Image for a YUV 422 image used by Primesense devices
pcl::visualization::ImageViewer | ImageViewer is a class for 2D image visualization
pcl::visualization::RangeImageVisualizer | Range image visualizer class
pcl::ism::ImplicitShapeModelEstimation< FeatureSize, PointT, NormalT > | This class implements Implicit Shape Model algorithm described in "Hough Transforms and 3D SURF for robust three dimensional classication" by Jan Knopp1, Mukta Prasad, Geert Willems1, Radu Timofte, and Luc Van Gool
pcl::registration::IncrementalRegistration< PointT, Scalar > | Incremental IterativeClosestPoint class
INCVMemAllocator | INCVMemAllocator (Interface)
NCVMemNativeAllocator | NCVMemNativeAllocator
NCVMemStackAllocator | NCVMemStackAllocator
flann::Index< T > |
inflate_state |
pcl::device::InitalSimplex |
Loki::Int2Type< v > |
pcl::IntegralImage2D< DataType, Dimension > | Determines an integral image representation for a given organized data array
pcl::IntegralImage2D< DataType, 1 > | Partial template specialization for integral images with just one channel
pcl::IntegralImage2D< float, 1 > |
pcl::IntegralImage2D< float, 3 > |
pcl::IntegralImageTypeTraits< DataType > |
pcl::IntegralImageTypeTraits< char > |
pcl::IntegralImageTypeTraits< float > |
pcl::IntegralImageTypeTraits< int > |
pcl::IntegralImageTypeTraits< short > |
pcl::IntegralImageTypeTraits< unsigned char > |
pcl::IntegralImageTypeTraits< unsigned int > |
pcl::IntegralImageTypeTraits< unsigned short > |
pcl::common::IntensityFieldAccessor< PointT > |
pcl::common::IntensityFieldAccessor< pcl::InterestPoint > |
pcl::common::IntensityFieldAccessor< pcl::PointNormal > |
pcl::common::IntensityFieldAccessor< pcl::PointSurfel > |
pcl::common::IntensityFieldAccessor< pcl::PointWithRange > |
pcl::common::IntensityFieldAccessor< pcl::PointWithScale > |
pcl::common::IntensityFieldAccessor< pcl::PointWithViewpoint > |
pcl::common::IntensityFieldAccessor< pcl::PointXYZ > |
pcl::common::IntensityFieldAccessor< pcl::PointXYZHSV > |
pcl::common::IntensityFieldAccessor< pcl::PointXYZL > |
pcl::common::IntensityFieldAccessor< pcl::PointXYZLNormal > |
pcl::common::IntensityFieldAccessor< pcl::PointXYZRGB > |
pcl::common::IntensityFieldAccessor< pcl::PointXYZRGBA > |
pcl::common::IntensityFieldAccessor< pcl::PointXYZRGBL > |
pcl::common::IntensityFieldAccessor< pcl::PointXYZRGBNormal > |
pcl::common::IntensityFieldAccessor< PointInT > |
pcl::common::IntensityFieldAccessor< PointOutT > |
pcl::IntensityGradient | A point structure representing the intensity gradient of an XYZI point cloud
pcl::InterestPoint | A point structure representing an interest point with Euclidean xyz coordinates, and an interest value
internal_state |
pcl::intersect< Sequence1, Sequence2 > |
pcl::device::Intr | Camera intrinsics structure
pcl::TSDFVolume< VoxelT, WeightT >::Intr | Camera intrinsics structure
pcl::device::kinfuLS::Intr | Camera intrinsics structure
pcl::io::IRImage | Class containing just a reference to IR meta data
openni_wrapper::IRImage | Class containing just a reference to IR meta data
boost::detail::is_random_access< eigen_listS > |
boost::detail::is_random_access< eigen_vecS > |
pcl::detail::IsAccumulatorCompatible< Point1T, Point2T > |
pcl::PosesFromMatches::PoseEstimate::IsBetter |
pcl_cuda::isFiniteAOS | Check if a specific point is valid or not
pcl_cuda::isFiniteSOA | Check if a specific point is valid or not
pcl_cuda::isFiniteZIPSOA | Check if a specific point is valid or not
pcl::cuda::isInlier | Check if a certain tuple is a point inlier
pcl::features::ISMModel | The assignment of this structure is to store the statistical/learned weights and other information of the trained Implict Shape Model algorithm
pcl::ISMPeak | This struct is used for storing peak
pcl::features::ISMVoteList< PointT > | This class is used for storing, analyzing and manipulating votes obtained from ISM algorithm
pcl::cuda::isNaNPoint |
pcl::cuda::isNotInlier |
pcl::cuda::isNotZero< T > |
iterator |
pcl::octree::OctreeIteratorBase< OctreeT > | Abstract octree iterator class
pcl::octree::OctreeBreadthFirstIterator< OctreeT > | Octree iterator class
pcl::octree::OctreeFixedDepthIterator< OctreeT > | Octree iterator class
pcl::octree::OctreeLeafNodeBreadthFirstIterator< OctreeT > | Octree leaf node iterator class
pcl::octree::OctreeDepthFirstIterator< OctreeT > | Octree iterator class
pcl::octree::OctreeLeafNodeDepthFirstIterator< OctreeT > | Octree leaf node iterator class
pcl::outofcore::OutofcoreIteratorBase< PointT, ContainerT > | Abstract octree iterator class
pcl::outofcore::OutofcoreBreadthFirstIterator< PointT, ContainerT > |
pcl::outofcore::OutofcoreDepthFirstIterator< PointT, ContainerT > |
pcl::IteratorIdx< PointT > |
pcl::octree::IteratorState |
pcl::KdTree< PointT > | KdTree represents the base spatial locator class for kd-tree implementations
pcl::KdTreeFLANN< PointT > |
pcl::KdTreeFLANN< PointT, Dist > | KdTreeFLANN is a generic type of 3D spatial locator using kD-tree structures
pcl::KdTree< FeatureT > |
pcl::KdTreeFLANN< FeatureT > |
pcl::KdTree< pcl::InterestPoint > |
pcl::KdTreeFLANN< pcl::InterestPoint > |
pcl::KdTree< pcl::PointXYZ > |
pcl::KdTreeFLANN< pcl::PointXYZ > |
pcl::KdTree< pcl::PointXYZRGB > |
pcl::KdTreeFLANN< pcl::PointXYZRGB > |
pcl::KdTree< pcl::VFHSignature308 > |
pcl::KdTreeFLANN< pcl::VFHSignature308 > |
pcl::KdTree< PointTarget > |
pcl::KdTreeFLANN< PointTarget > |
pcl::KdTree< SceneT > |
pcl::KdTreeFLANN< SceneT > |
pcl::kernel< PointT > |
pcl::kernel< PointInT > |
NCVRuntimeTemplateBool::KernelCaller< TList, NumArguments, Func > |
NCVRuntimeTemplateBool::KernelCaller< TList, 0, Func > |
pcl::visualization::KeyboardEvent | /brief Class representing key hit/release events
pcl::gpu::KinfuTracker | KinfuTracker class encapsulates implementation of Microsoft Kinect Fusion algorithm
pcl::gpu::kinfuLS::KinfuTracker | KinfuTracker class encapsulates implementation of Microsoft Kinect Fusion algorithm
kiss_fft_cpx |
kiss_fft_state |
pcl::Kmeans | K-means clustering
flann::L2< T > |
flann::L2_Simple< T > |
pcl::Label |
pcl::gpu::people::trees::LabeledAttrib |
pcl::gpu::people::trees::LabeledFeature |
pcl::keypoints::brisk::Layer | A layer in the BRISK detector pyramid
pcl::LCCPSegmentation< PointT > | A simple segmentation algorithm partitioning a supervoxel graph into groups of locally convex connected supervoxels separated by concave borders
pcl::CPCSegmentation< PointT > | A segmentation algorithm partitioning a supervoxel graph
pcl::UniformSampling< PointT >::Leaf | Simple structure to hold an nD centroid and the number of points in a leaf
pcl::VoxelGridCovariance< PointT >::Leaf | Simple structure to hold a centroid, covarince and the number of points in a leaf
pcl::GridProjection< PointNT >::Leaf | Data leaf
pcl::MovingLeastSquares< PointInT, PointOutT >::MLSVoxelGrid::Leaf |
pcl::device::LessThanByFacet |
pcl::device::LightSource | Light source collection
pcl::device::kinfuLS::LightSource | Light source collection
pcl::LinearizedMaps | Stores a set of linearized maps
pcl::LINEMOD | Template matching using the LINEMOD approach
pcl::LINEMOD_OrientationMap | Map that stores orientations
pcl::LINEMODDetection | Represents a detection of a template using the LINEMOD approach
pcl::LineRGBD< PointXYZT, PointRGBT > | High-level class for template matching using the LINEMOD approach based on RGB and Depth data
pcl::io::ply::ply_parser::list_property_begin_callback_type< SizeType, ScalarType > |
pcl::io::ply::ply_parser::list_property_begin_callback_type< size_type, scalar_type > |
pcl::io::ply::ply_parser::list_property_definition_callback_type< SizeType, ScalarType > |
pcl::io::ply::ply_parser::list_property_definition_callback_type< size_type, scalar_type > |
pcl::io::ply::ply_parser::list_property_definition_callbacks_type |
pcl::io::ply::ply_parser::list_property_element_callback_type< SizeType, ScalarType > |
pcl::io::ply::ply_parser::list_property_element_callback_type< size_type, scalar_type > |
pcl::io::ply::ply_parser::list_property_end_callback_type< SizeType, ScalarType > |
pcl::io::ply::ply_parser::list_property_end_callback_type< size_type, scalar_type > |
pcl::RangeImageBorderExtractor::LocalSurface | Stores some information extracted from the neighborhood of a point
pcl::ism::ImplicitShapeModelEstimation< FeatureSize, PointT, NormalT >::LocationInfo | This structure stores the information about the keypoint
LRUCache< KeyT, CacheItemT > |
LRUCacheItem< T > |
LRUCacheItem< vtkSmartPointer< vtkPolyData > > |
OutofcoreCloud::CloudDataCacheItem |
pcl::registration::LUM< PointT > | Globally Consistent Scan Matching based on an algorithm by Lu and Milios
pcl::io::LZFImageReader | PCL-LZF image format reader
pcl::io::LZFDepth16ImageReader | PCL-LZF 16-bit depth image format reader
pcl::io::LZFRGB24ImageReader | PCL-LZF 24-bit RGB image format reader
pcl::io::LZFBayer8ImageReader | PCL-LZF 8-bit Bayer image format reader
pcl::io::LZFYUV422ImageReader | PCL-LZF 8-bit Bayer image format reader
pcl::io::LZFImageWriter | PCL-LZF image format writer
pcl::io::LZFDepth16ImageWriter | PCL-LZF 16-bit depth image format writer
pcl::io::LZFRGB24ImageWriter | PCL-LZF 24-bit RGB image format writer
pcl::io::LZFBayer8ImageWriter | PCL-LZF 8-bit Bayer image format writer
pcl::io::LZFYUV422ImageWriter | PCL-LZF 16-bit YUV422 image format writer
ON_SerialNumberMap::MAP_VALUE |
pcl::poisson::MapReduceVector< T2 > |
pcl::gpu::MarchingCubes | MarchingCubes implements MarchingCubes functionality for TSDF volume on GPU
pcl::gpu::kinfuLS::MarchingCubes | MarchingCubes implements MarchingCubes functionality for TSDF volume on GPU
pcl::poisson::MarchingCubes |
pcl::poisson::MarchingSquares |
pcl::MaskMap |
pcl::device::Mat33 | 3x3 Matrix for device code
pcl::device::kinfuLS::Mat33 | 3x3 Matrix for device code
pcl::registration::MatchingCandidate | Container for matching candidate consisting of
flann::Matrix< T > |
pcl::poisson::MatrixEntry< T > |
Mesh |
pcl::geometry::MeshBase< DerivedT, MeshTraitsT, MeshTagT > | Base class for the half-edge mesh
pcl::geometry::MeshBase< PolygonMesh< MeshTraitsT >, MeshTraitsT, PolygonMeshTag > |
pcl::geometry::PolygonMesh< MeshTraitsT > | General half-edge mesh that can store any polygon with a minimum number of vertices of 3
pcl::geometry::MeshBase< QuadMesh< MeshTraitsT >, MeshTraitsT, QuadMeshTag > |
pcl::geometry::QuadMesh< MeshTraitsT > | Half-edge mesh that can only store quads
pcl::geometry::MeshBase< TriangleMesh< MeshTraitsT >, MeshTraitsT, TriangleMeshTag > |
pcl::geometry::TriangleMesh< MeshTraitsT > | Half-edge mesh that can only store triangles
pcl::geometry::MeshIO< MeshT > | Read / write the half-edge mesh from / to a file
pcl::MeshProcessing | MeshProcessing represents the base class for mesh processing algorithms
pcl::EarClipping | The ear clipping triangulation algorithm
pcl::MeshQuadricDecimationVTK | PCL mesh decimation based on vtkQuadricDecimation from the VTK library
pcl::MeshSmoothingLaplacianVTK | PCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library
pcl::MeshSmoothingWindowedSincVTK | PCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library
pcl::MeshSubdivisionVTK | PCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library
pcl::registration::MetaRegistration< PointT, Scalar > | Meta Registration class
pcl::poisson::MinimalAreaTriangulation< Real > |
pcl::device::kinfuLS::Eigen33::MiniMat< Rows > |
pcl::device::Eigen33::MiniMat< Rows > |
pcl::MLSResult::MLSProjectionResults | Data structure used to store the MLS projection results
pcl::MLSResult | Data structure used to store the results of the MLS fitting
pcl::MovingLeastSquares< PointInT, PointOutT >::MLSVoxelGrid | A minimalistic implementation of a voxel grid, necessary for the point cloud upsampling
pcl::RealSenseGrabber::Mode | A descriptor for capturing mode
pcl::OpenNIGrabber::modeComp |
pcl::recognition::ModelLibrary::Model | Stores some information about the model
pcl::ModelCoefficients |
pcl::recognition::ModelLibrary |
pcl::MomentInvariants | A point structure representing the three moment invariants
pcl::device::Morton |
pcl::visualization::MouseEvent |
pcl::MTLReader |
pcl::MultiChannel2DComparisonFeature< PointT > | Feature for comparing two sample points in 2D multi-channel data
pcl::MultiChannel2DData< DATA_TYPE, NUM_OF_CHANNELS > | Holds two-dimensional multi-channel data
pcl::MultiChannel2DDataSet< DATA_TYPE, NUM_OF_CHANNELS > | Holds a set of two-dimensional multi-channel data
pcl::MultipleData2DExampleIndex | Example index for a set of 2D data blocks
pcl::device::MultiTreeLiveProc | Processor using multiple trees
pcl::traits::name< PointT, Tag, dummy > |
pcl::Narf | NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data
pcl::Narf36 | A point structure representing the Narf descriptor
NCVMatrix< T > | NCVMatrix (2D)
NCVMatrixAlloc< T > | NCVMatrixAlloc
NCVMatrixReuse< T > | NCVMatrixReuse
NCVMemPtr | NCVMemPtr
NCVMemSegment | NCVMemSegment
NcvPoint2D32s |
NcvPoint2D32u |
NcvRect32s |
NcvRect32u |
NcvRect8u |
NcvSize32s |
NcvSize32u |
NCVVector< T > | NCVVector (1D)
NCVVectorAlloc< T > | NCVVectorAlloc
NCVVectorReuse< T > | NCVVectorReuse
NCVVector< HaarClassifierNode128 > |
NCVVectorAlloc< HaarClassifierNode128 > |
NCVVector< HaarFeature64 > |
NCVVectorAlloc< HaarFeature64 > |
NCVVector< HaarStage64 > |
NCVVectorAlloc< HaarStage64 > |
pcl::NdCentroidFunctor< PointT, Scalar > | Helper functor structure for n-D centroid estimation
pcl::NdConcatenateFunctor< PointInT, PointOutT > | Helper functor structure for concatenate
pcl::NdCopyEigenPointFunctor< PointOutT > | Helper functor structure for copying data between an Eigen type and a PointT
pcl::NdCopyPointEigenFunctor< PointInT > | Helper functor structure for copying data between an Eigen type and a PointT
pcl::OrganizedNeighborSearch< PointT >::nearestNeighborCandidate | nearestNeighborCandidate entry for the nearest neighbor candidate queue
pcl::OrganizedEdgeBase< PointT, PointLT >::Neighbor |
pcl::gpu::NeighborIndices |
pcl::poisson::OctNode< NodeData, Real >::NeighborKey3 |
pcl::poisson::OctNode< NodeData, Real >::NeighborKey5 |
pcl::Permutohedral::Neighbors |
pcl::poisson::OctNode< NodeData, Real >::Neighbors3 |
pcl::poisson::OctNode< NodeData, Real >::Neighbors5 |
pcl::cuda::NewCheckPlanarInlier< Storage > | Check if a certain tuple is a point inlier
NewFrameListener |
pcl::io::openni2::OpenNI2FrameListener |
pcl::GrabCut< PointT >::NLinks |
flann::NNIndex< T > |
pcl::geometry::NoData | No data is associated with the vertices / half-edges / edges / faces
pcl::recognition::BVH< UserData >::Node |
pcl::recognition::ORRGraph< NodeData >::Node |
pcl::recognition::ORROctree::Node |
pcl::recognition::SimpleOctree< NodeData, NodeDataCreator, Scalar >::Node |
pcl::gpu::people::trees::Node |
pcl::device::NonCachedLoad< T > |
noncopyable |
MonitorQueue< DataT > |
pcl::io::depth_sense::DepthSenseDeviceManager | A helper class for enumerating and managing access to DepthSense devices
pcl::io::real_sense::RealSenseDevice |
pcl::io::real_sense::RealSenseDeviceManager |
pcl::ndt2d::NDT2D< PointT > | Build a Normal Distributions Transform of a 2D point cloud
pcl::ndt2d::NDTSingleGrid< PointT > | 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
pcl::visualization::CloudViewer | Simple point cloud visualization class
pcl::gpu::DataSource::Normal2PointXYZ |
pcl::common::normal_distribution< T > | Normal distribution
pcl::NormalBasedSignature12 | A point structure representing the Normal Based Signature for a feature matrix of 4-by-3
pcl::cuda::NormalDeviationKernel< Storage > |
pcl::ndt2d::NormalDist< PointT > | A normal distribution estimation class
pcl::cuda::NormalEstimationKernel< Storage > |
pcl::common::NormalGenerator< T > | NormalGenerator class generates a random number from a normal distribution specified by (mean, sigma)
NppStInterpolationState | Frame interpolation state
pcl::registration::NullEstimate | NullEstimate struct
pcl::registration::NullMeasurement | NullMeasurement struct
Loki::NullType |
Eigen::NumTraits< pcl::ndt2d::NormalDist< PointT > > |
pcl::poisson::NVector< T, Dim > |
Object |
Axes |
Camera |
Geometry |
Grid |
OutofcoreCloud |
ObjectFeatures |
ObjectModel |
ObjectRecognition |
ObjectRecognitionParameters |
pcl::recognition::ObjRecRANSAC | This is a RANSAC-based 3D object recognition method
pcl::poisson::OctNode< NodeData, Real > |
pcl::poisson::OctNode< class TreeNodeData, Real > |
pcl::gpu::Octree | Octree implementation on GPU
pcl::poisson::Octree< Degree > |
pcl::octree::Octree2BufBase< LeafContainerT, BranchContainerT > | Octree double buffer class
pcl::octree::OctreePointCloud< PointT, LeafContainerT, BranchContainerT, Octree2BufBase< LeafContainerT, BranchContainerT > > |
pcl::octree::OctreePointCloudChangeDetector< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud change detector class
pcl::octree::Octree2BufBase< OctreeContainerPointIndices, OctreeContainerEmpty > |
pcl::octree::OctreePointCloud< PointInT, OctreeContainerPointIndices, OctreeContainerEmpty, Octree2BufBase< OctreeContainerPointIndices, OctreeContainerEmpty > > |
pcl::octree::OctreePointCloudChangeDetector< PointInT > |
pcl::octree::OctreeBase< LeafContainerT, BranchContainerT > | Octree class
pcl::octree::OctreePointCloud< PointT, LeafContainerT, BranchContainerT > |
pcl::octree::OctreePointCloudAdjacency< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud voxel class which maintains adjacency information for its voxels
pcl::octree::OctreePointCloudDensity< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud density class
pcl::octree::OctreePointCloudSearch< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud search class
pcl::octree::OctreePointCloudVoxelCentroid< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud voxel centroid class
pcl::octree::OctreePointCloud< PointT, LeafContainerT, BranchContainerT, OctreeBase< LeafContainerT, BranchContainerT > > |
pcl::octree::OctreePointCloudOccupancy< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud occupancy class
pcl::octree::OctreeBase< LeafTWrap, BranchTWrap > |
pcl::octree::OctreePointCloud< PointT, LeafTWrap, BranchTWrap > |
pcl::octree::OctreePointCloudSearch< PointT, LeafTWrap, BranchTWrap > |
pcl::octree::OctreeBase< pcl::octree::OctreeContainerPointIndices, pcl::octree::OctreeContainerEmpty > |
pcl::octree::OctreePointCloud< PointInT, pcl::octree::OctreeContainerPointIndices, pcl::octree::OctreeContainerEmpty > |
pcl::octree::OctreePointCloudSearch< PointInT, pcl::octree::OctreeContainerPointIndices, pcl::octree::OctreeContainerEmpty > |
pcl::octree::OctreeContainerBase | Octree container class that can serve as a base to construct own leaf node container classes
pcl::octree::OctreeContainerEmpty | Octree container class that does not store any information
pcl::octree::OctreeContainerPointIndex | Octree container class that does store a single point index
pcl::octree::OctreeContainerPointIndices | Octree container class that does store a vector of point indices
pcl::octree::OctreePointCloudAdjacencyContainer< PointInT, DataT > | Octree adjacency leaf container class- stores a list of pointers to neighbors, number of points added, and a DataT value
pcl::octree::OctreePointCloudDensityContainer | Octree pointcloud density leaf node class
pcl::octree::OctreePointCloudVoxelCentroidContainer< PointT > | Octree pointcloud voxel centroid leaf node class
pcl::device::OctreeImpl::OctreeDataHost |
pcl::device::OctreeGlobal |
pcl::device::OctreeGlobalWithBox |
pcl::device::OctreeImpl |
pcl::device::OctreeIteratorDevice< CTA_SIZE, STACK_DEPTH > |
pcl::device::OctreeIteratorDeviceNS |
pcl::octree::OctreeKey | Octree key class
pcl::octree::OctreeNode | Abstract octree node class
pcl::octree::BufferedBranchNode< ContainerT > |
pcl::octree::OctreeBranchNode< ContainerT > | Abstract octree branch class
pcl::octree::OctreeLeafNode< ContainerT > | Abstract octree leaf class
pcl::outofcore::OutofcoreOctreeBaseNode< ContainerT, PointT > | 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.
pcl::octree::OctreeNodePool< NodeT > | Octree node pool
pcl::device::OctreePriorityIteratorDevice |
OctreeT |
pcl::octree::OctreePointCloud< PointT, LeafT, BranchT, OctreeT > |
pcl::io::OctreePointCloudCompression< PointT, LeafT, BranchT, OctreeT > | Octree pointcloud compression class
pcl::octree::OctreePointCloud< PointT, LeafContainerT, BranchContainerT, OctreeT > | Octree pointcloud class
pcl::octree::OctreePointCloudPointVector< PointT, LeafContainerT, BranchContainerT, OctreeT > | Octree pointcloud point vector class
pcl::octree::OctreePointCloudSinglePoint< PointT, LeafContainerT, BranchContainerT, OctreeT > | Octree pointcloud single point class
pcl::traits::offset< PointT, Tag > |
ON_2dPoint |
ON_2dVector |
ON_2fPoint |
ON_2fVector |
ON_3DM_BIG_CHUNK |
ON_3DM_CHUNK |
ON_3dmAnnotationSettings |
ON_3dmApplication |
ON_3dmConstructionPlane |
ON_3dmConstructionPlaneGridDefaults |
ON_3dmGoo |
ON_3dmIOSettings |
ON_3dmNotes |
ON_3dmPageSettings |
ON_3dmProperties |
ON_3dmRenderSettings |
ON_3dmRevisionHistory |
ON_3dmSettings |
ON_3dmUnitsAndTolerances |
ON_3dmView |
ON_3dmViewPosition |
ON_3dmViewTraceImage |
ON_3dmWallpaperImage |
ON_3dPoint |
ON_3dRay |
ON_3dVector |
ON_PlaneEquation |
ON_3fPoint |
ON_3fVector |
ON_4dPoint |
ON_4fPoint |
ON_Base64EncodeStream |
ON_BezierCage |
ON_BezierCurve |
ON_BezierSurface |
ON_BinaryArchive |
ON_BinaryArchiveBuffer |
ON_BinaryFile |
ON_Read3dmBufferArchive |
ON_Write3dmBufferArchive |
ON_BoundingBox |
ON_Box |
ON_BrepRegionTopology |
ON_BrepTrimPoint |
ON_Buffer |
ON_BumpFunction |
ON_CheckSum |
ON_Circle |
ON_Arc |
ON_ClassArray< T > |
ON_ObjectArray< T > |
ON_ClassArray< ON_3dmConstructionPlane > |
ON_ClassArray< ON_3dmView > |
ON_ClassArray< ON_BrepEdge > |
ON_ObjectArray< ON_BrepEdge > |
ON_BrepEdgeArray |
ON_ClassArray< ON_BrepFace > |
ON_ObjectArray< ON_BrepFace > |
ON_BrepFaceArray |
ON_ClassArray< ON_BrepFaceSide > |
ON_ObjectArray< ON_BrepFaceSide > |
ON_BrepFaceSideArray |
ON_ClassArray< ON_BrepLoop > |
ON_ObjectArray< ON_BrepLoop > |
ON_BrepLoopArray |
ON_ClassArray< ON_BrepRegion > |
ON_ObjectArray< ON_BrepRegion > |
ON_BrepRegionArray |
ON_ClassArray< ON_BrepTrim > |
ON_ObjectArray< ON_BrepTrim > |
ON_BrepTrimArray |
ON_ClassArray< ON_BrepVertex > |
ON_ObjectArray< ON_BrepVertex > |
ON_BrepVertexArray |
ON_ClassArray< ON_CurveProxyHistory > |
ON_ClassArray< ON_DimStyle > |
ON_ObjectArray< ON_DimStyle > |
ON_ClassArray< ON_Font > |
ON_ObjectArray< ON_Font > |
ON_ClassArray< ON_Group > |
ON_ObjectArray< ON_Group > |
ON_ClassArray< ON_HatchLine > |
ON_ClassArray< ON_HatchPattern > |
ON_ObjectArray< ON_HatchPattern > |
ON_ClassArray< ON_InstanceDefinition > |
ON_ObjectArray< ON_InstanceDefinition > |
ON_ClassArray< ON_Layer > |
ON_ObjectArray< ON_Layer > |
ON_ClassArray< ON_Linetype > |
ON_ObjectArray< ON_Linetype > |
ON_ClassArray< ON_Localizer > |
ON_ClassArray< ON_MappingRef > |
ON_ClassArray< ON_Material > |
ON_ObjectArray< ON_Material > |
ON_ClassArray< ON_MaterialRef > |
ON_ClassArray< ON_PlugInRef > |
ON_ClassArray< ON_Texture > |
ON_ObjectArray< ON_Texture > |
ON_ClassArray< ON_TextureCoordinates > |
ON_ClassArray< ON_TextureMapping > |
ON_ObjectArray< ON_TextureMapping > |
ON_ClassArray< ON_UserString > |
ON_ClassArray< ONX_Model_Object > |
ON_ClassArray< ONX_Model_RenderLight > |
ON_ClassArray< ONX_Model_UserData > |
ON_ClassId |
ON_ClippingPlane |
ON_ClippingPlaneInfo |
ON_ClippingRegion |
ON_Color |
ON_CompressedBuffer |
ON_CompressStream |
ON_Cone |
ON_CurveProxyHistory |
ON_Cylinder |
ON_DecodeBase64 |
ON_DisplayMaterialRef |
ON_EarthAnchorPoint |
ON_Ellipse |
ON_Evaluator |
ON_FileIterator |
ON_FileStream |
ON_FixedSizePool |
ON_SimpleFixedSizePool< T > |
ON_FixedSizePoolIterator |
ON_HatchLine |
ON_HatchLoop |
ON_Interval |
ON_Line |
ON_LinetypeSegment |
ON_Localizer |
ON_LocalZero1 |
ON_MappingChannel |
ON_MappingRef |
ON_MappingTag |
ON_MaterialRef |
ON_Matrix |
ON_MeshCurvatureStats |
ON_MeshCurveParameters |
ON_MeshFace |
ON_MeshFaceSide |
ON_MeshNgon |
ON_MeshNgonList |
ON_MeshParameters |
ON_MeshPart |
ON_MeshPartition |
ON_MeshTopology |
ON_MeshTopologyEdge |
ON_MeshTopologyFace |
ON_MeshTopologyVertex |
ON_Object |
ON_3dmObjectAttributes |
ON_Bitmap |
ON_EmbeddedBitmap |
ON_WindowsBitmap |
ON_WindowsBitmapEx |
ON_BrepFaceSide |
ON_BrepRegion |
ON_DimStyle |
ON_DocumentUserStringList |
ON_EmbeddedFile |
ON_Font |
ON_Geometry |
ON_Annotation |
ON_AngularDimension |
ON_Leader |
ON_LinearDimension |
ON_RadialDimension |
ON_TextEntity |
ON_Annotation2 |
ON_AngularDimension2 |
ON_Leader2 |
ON_LinearDimension2 |
ON_OrdinateDimension2 |
ON_RadialDimension2 |
ON_TextEntity2 |
ON_AnnotationArrow |
ON_Brep |
ON_BrepLoop |
ON_Curve |
ON_ArcCurve |
ON_CurveOnSurface |
ON_CurveProxy |
ON_BrepEdge |
ON_BrepTrim |
ON_PolyEdgeSegment |
ON_LineCurve |
ON_NurbsCurve |
ON_PolyCurve |
ON_PolyEdgeCurve |
ON_PolylineCurve |
ON_DetailView |
ON_Hatch |
ON_InstanceDefinition |
ON_InstanceRef |
ON_Light |
ON_Mesh |
ON_MeshEdgeRef |
ON_MeshFaceRef |
ON_MeshVertexRef |
ON_MorphControl |
ON_NurbsCage |
ON_Point |
ON_AnnotationTextDot |
ON_BrepVertex |
ON_PointCloud |
ON_PointGrid |
ON_Surface |
ON_Extrusion |
ON_NurbsSurface |
ON_PlaneSurface |
ON_ClippingPlaneSurface |
ON_RevSurface |
ON_SumSurface |
ON_SurfaceProxy |
ON_BrepFace |
ON_OffsetSurface |
ON_TextDot |
ON_Viewport |
ON_Group |
ON_HatchPattern |
ON_HistoryRecord |
ON_Layer |
ON_Linetype |
ON_Material |
ON_Texture |
ON_TextureMapping |
ON_UserData |
ON_DimensionExtra |
ON_TextExtra |
ON_UnknownUserData |
ON_UserStringList |
ON_UserDataHolder |
ON_ObjRef |
ON_ObjRef_IRefID |
ON_ObjRefEvaluationParameter |
ON_OffsetSurfaceFunction |
ON_OffsetSurfaceValue |
ON_Plane |
ON_PlugInRef |
ON_PolyEdgeHistory |
ON_PolynomialCurve |
ON_PolynomialSurface |
ON_RANDOM_NUMBER_CONTEXT |
ON_RenderingAttributes |
ON_ObjectRenderingAttributes |
ON_RTree |
ON_RTreeBBox |
ON_RTreeBranch |
ON_RTreeCapsule |
ON_RTreeIterator |
ON_RTreeLeaf |
ON_RTreeMemPool |
ON_RTreeNode |
ON_RTreeSearchResult |
ON_RTreeSphere |
ON_SerialNumberMap |
ON_SimpleArray< T > |
ON_SimpleArray< bool > |
ON_SimpleArray< class ON_BumpFunction > |
ON_SimpleArray< class ON_Value * > |
ON_SimpleArray< double * > |
ON_SimpleArray< double > |
ON_SimpleArray< int > |
ON_SimpleArray< ON_2dex > |
ON_2dexMap |
ON_SimpleArray< ON_2dPoint > |
ON_2dPointArray |
ON_SimpleArray< ON_2dVector > |
ON_2dVectorArray |
ON_SimpleArray< ON_2fPoint > |
ON_2fPointArray |
ON_SimpleArray< ON_2fVector > |
ON_2fVectorArray |
ON_SimpleArray< ON_3DM_BIG_CHUNK > |
ON_SimpleArray< ON_3dPoint > |
ON_3dPointArray |
ON_Polyline |
ON_SimpleArray< ON_3dVector > |
ON_3dVectorArray |
ON_SimpleArray< ON_3fPoint > |
ON_3fPointArray |
ON_SimpleArray< ON_3fVector > |
ON_3fVectorArray |
ON_SimpleArray< ON_4dPoint > |
ON_4dPointArray |
ON_SimpleArray< ON_4fPoint > |
ON_4fPointArray |
ON_SimpleArray< ON_Bitmap * > |
ON_SimpleArray< ON_BrepTrimPoint > |
ON_SimpleArray< ON_ClippingPlaneInfo > |
ON_SimpleArray< ON_Color > |
ON_SimpleArray< ON_Curve * > |
ON_CurveArray |
ON_SimpleArray< ON_DisplayMaterialRef > |
ON_SimpleArray< ON_HatchLoop * > |
ON_SimpleArray< ON_HistoryRecord * > |
ON_SimpleArray< ON_Interval > |
ON_SimpleArray< ON_LinetypeSegment > |
ON_SimpleArray< ON_MappingChannel > |
ON_SimpleArray< ON_MeshFace > |
ON_SimpleArray< ON_MeshTopologyEdge > |
ON_SimpleArray< ON_MeshTopologyFace > |
ON_SimpleArray< ON_MeshTopologyVertex > |
ON_SimpleArray< ON_ObjRef_IRefID > |
ON_SimpleArray< ON_OffsetSurfaceValue > |
ON_SimpleArray< ON_Surface * > |
ON_SurfaceArray |
ON_SimpleArray< ON_SurfaceCurvature > |
ON_SimpleArray< ON_UUID > |
ON_UuidList |
ON_SimpleArray< ON_UuidIndex > |
ON_UuidIndexList |
ON_SimpleArray< ON_UuidPair > |
ON_UuidPairList |
ON_SimpleArray< struct ON_MeshPart > |
ON_SpaceMorph |
ON_BezierCageMorph |
ON_CageMorph |
ON_Sphere |
ON_String |
ON_Sum |
ON_SurfaceCurvature |
ON_SurfaceProperties |
ON_TensorProduct |
ON_TextLog |
ON_TextureCoordinates |
ON_Torus |
ON_U |
ON_UncompressStream |
ON_UnicodeErrorParameters |
ON_UnitSystem |
ON_UserString |
ON_UUID |
ON_UuidPair |
ON_WindowsBITMAPINFO |
ON_WindowsBITMAPINFOHEADER |
ON_WindowsRGBQUAD |
ON_Workspace |
ON_wString |
ON_Annotation2Text |
ON_Xform |
ONX_Model |
ONX_Model_Object |
ONX_Model_RenderLight |
ONX_Model_UserData |
pcl::io::openni2::OpenNI2Device |
pcl::io::openni2::OpenNI2DeviceInfo |
pcl::io::openni2::OpenNI2DeviceManager |
pcl::io::openni2::OpenNI2TimerFilter |
pcl::io::openni2::OpenNI2VideoMode |
OpenNICapture |
openni_wrapper::OpenNIDevice | Class representing an astract device for OpenNI devices: Primesense PSDK, Microsoft Kinect, Asus Xtion Pro/Live
openni_wrapper::DeviceKinect | Concrete implementation of the interface OpenNIDevice for a MS Kinect device
openni_wrapper::DeviceONI | Concrete implementation of the interface OpenNIDevice for a virtual device playing back an ONI file
openni_wrapper::DevicePrimesense | Concrete implementation of the interface OpenNIDevice for a Primesense device
openni_wrapper::DeviceXtionPro | Concrete implementation of the interface OpenNIDevice for a Asus Xtion Pro device
openni_wrapper::OpenNIDriver | Driver class implemented as Singleton
pcl::cuda::OpenNIRGB | Simple structure holding RGB data
pcl::io::OrganizedConversion< PointT, enableColor > |
pcl::io::OrganizedConversion< PointT, false > |
pcl::io::OrganizedConversion< PointT, true > |
pcl::OrganizedIndexIterator | Base class for iterators on 2-dimensional maps like images/organized clouds etc
pcl::LineIterator | Organized Index Iterator for iterating over the "pixels" for a given line using the Bresenham algorithm
pcl::OrganizedNeighborSearch< PointT > | OrganizedNeighborSearch class
pcl::gpu::people::OrganizedPlaneDetector |
pcl::io::OrganizedPointCloudCompression< PointT > |
pcl::cuda::OrganizedRadiusSearch< CloudPtr > | Kernel to compute a radius neighborhood given a organized point cloud (aka range image cloud)
pcl::cuda::OrganizedRadiusSearch< CloudConstPtr > |
pcl::recognition::ObjRecRANSAC::OrientedPointPair |
pcl::recognition::ORRGraph< NodeData > |
pcl::recognition::ORROctree | That's a very specialized and simple octree class
pcl::recognition::ORROctreeZProjection |
pcl::outofcore::OutofcoreAbstractMetadata |
pcl::outofcore::OutofcoreOctreeBaseMetadata | Encapsulated class to read JSON metadata into memory, and write the JSON metadata associated with the octree root node. This is global information that is not the same as the metadata for the root node. Inherits OutofcoreAbstractMetadata interface for metadata in pcl_outofcore
pcl::outofcore::OutofcoreAbstractNodeContainer< PointT > |
pcl::outofcore::OutofcoreOctreeDiskContainer< PointT > | Class responsible for serialization and deserialization of out of core point data
pcl::outofcore::OutofcoreOctreeRamContainer< PointT > | Storage container class which the outofcore octree base is templated against
pcl::outofcore::OutofcoreOctreeBase< ContainerT, PointT > | This code defines the octree used for point storage at Urban Robotics
pcl::outofcore::OutofcoreOctreeBase< ContainerT, pcl::PointXYZRGB > |
pcl::outofcore::OutofcoreOctreeNodeMetadata | Encapsulated class to read JSON metadata into memory, and write the JSON metadata for each node
pcl::outofcore::OutofcoreParams |
pcl::recognition::ObjRecRANSAC::Output | This is an output item of the ObjRecRANSAC::recognize() method
pair |
pcl::PPFHashMapSearch::HashKeyStruct | Data structure to hold the information for the key in the feature hash map of the PPFHashMapSearch class
pcl::PairwisePotential |
boost::parallel_edge_traits< eigen_listS > |
boost::parallel_edge_traits< eigen_vecS > |
pcl::cuda::parallel_random_generator |
pcl::PolynomialCalculationsT< real >::Parameters | Parameters used in this class
pcl::common::UniformGenerator< T >::Parameters |
BFGS< FunctorType >::Parameters |
pcl::common::NormalGenerator< T >::Parameters |
pcl::NarfDescriptor::Parameters |
pcl::RangeImageBorderExtractor::Parameters | Parameters used in this class
pcl::NarfKeypoint::Parameters | Parameters used in this class
pcl::PosesFromMatches::Parameters | Parameters used in this class
pcl::gpu::ParticleFilterGPUTracker |
OutofcoreCloud::PcdQueueItem |
pcl::PCLBase< PointT > | PCL base class
pcl::Feature< PointT, PointFeature > |
pcl::FeatureFromNormals< PointT, PointNT, PointFeature > |
pcl::NormalBasedSignatureEstimation< PointT, PointNT, PointFeature > | Normal-based feature signature estimation class
pcl::Keypoint< PointT, PointT > |
pcl::SmoothedSurfacesKeypoint< PointT, PointNT > | Based on the paper: Xinju Li and Igor Guskov Multi-scale features for approximate alignment of point-based surfaces Proceedings of the third Eurographics symposium on Geometry processing July 2005, Vienna, Austria
pcl::ApproximateProgressiveMorphologicalFilter< PointT > | Implements the Progressive Morphological Filter for segmentation of ground points
pcl::ConditionalEuclideanClustering< PointT > | ConditionalEuclideanClustering performs segmentation based on Euclidean distance and a user-defined clustering condition
pcl::EuclideanClusterExtraction< PointT > | EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense
pcl::ExtractPolygonalPrismData< PointT > | ExtractPolygonalPrismData uses a set of point indices that represent a planar model, and together with a given height, generates a 3D polygonal prism
pcl::Filter< PointT > | Filter represents the base filter class
pcl::ApproximateVoxelGrid< PointT > | ApproximateVoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::BilateralFilter< PointT > | A bilateral filter implementation for point cloud data
pcl::ConditionalRemoval< PointT > | ConditionalRemoval filters data that satisfies certain conditions
pcl::Convolution< PointT > | A 2D convolution class
pcl::FastBilateralFilter< PointT > | Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper:
pcl::FastBilateralFilterOMP< PointT > | Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper:
pcl::FilterIndices< PointT > | FilterIndices represents the base class for filters that are about binary point removal
pcl::CovarianceSampling< PointT, PointNT > | Point Cloud sampling based on the 6D covariances
pcl::CropBox< PointT > | CropBox is a filter that allows the user to filter all the data inside of a given box
pcl::CropHull< PointT > | Filter points that lie inside or outside a 3D closed surface or 2D closed polygon, as generated by the ConvexHull or ConcaveHull classes
pcl::ExtractIndices< PointT > | ExtractIndices extracts a set of indices from a point cloud
pcl::FrustumCulling< PointT > | FrustumCulling filters points inside a frustum given by pose and field of view of the camera
pcl::GridMinimum< PointT > | GridMinimum assembles a local 2D grid over a given PointCloud, and downsamples the data
pcl::LocalMaximum< PointT > | LocalMaximum downsamples the cloud, by eliminating points that are locally maximal
pcl::ModelOutlierRemoval< PointT > | ModelOutlierRemoval filters points in a cloud based on the distance between model and point
pcl::NormalSpaceSampling< PointT, NormalT > | NormalSpaceSampling samples the input point cloud in the space of normal directions computed at every point
pcl::PassThrough< PointT > | PassThrough passes points in a cloud based on constraints for one particular field of the point type
pcl::RadiusOutlierRemoval< PointT > | RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have
pcl::RandomSample< PointT > | RandomSample applies a random sampling with uniform probability
pcl::ShadowPoints< PointT, NormalT > | ShadowPoints removes the ghost points appearing on edge discontinuties
pcl::StatisticalOutlierRemoval< PointT > | StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data
pcl::MedianFilter< PointT > | Implementation of the median filter
pcl::ProjectInliers< PointT > | ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud
pcl::SamplingSurfaceNormal< PointT > | SamplingSurfaceNormal divides the input space into grids until each grid contains a maximum of N points, and samples points randomly within each grid
pcl::UniformSampling< PointT > | UniformSampling assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::VoxelGrid< PointT > | VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::VoxelGridCovariance< PointT > | A searchable voxel strucure containing the mean and covariance of the data
pcl::VoxelGridOcclusionEstimation< PointT > | VoxelGrid to estimate occluded space in the scene
pcl::GrabCut< PointT > | Implementation of the GrabCut segmentation in "GrabCut — Interactive Foreground Extraction using Iterated Graph Cuts" by Carsten Rother, Vladimir Kolmogorov and Andrew Blake
pcl::LabeledEuclideanClusterExtraction< PointT > | LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info
pcl::MinCutSegmentation< PointT > | This class implements the segmentation algorithm based on minimal cut of the graph
pcl::MomentOfInertiaEstimation< PointT > | Implements the method for extracting features based on moment of inertia
pcl::Morphology< PointT > |
pcl::OrganizedConnectedComponentSegmentation< PointT, PointLT > | OrganizedConnectedComponentSegmentation allows connected components to be found within organized point cloud data, given a comparison function
pcl::OrganizedEdgeBase< PointT, PointLT > | OrganizedEdgeBase, OrganizedEdgeFromRGB, OrganizedEdgeFromNormals, and OrganizedEdgeFromRGBNormals find 3D edges from an organized point cloud data
pcl::OrganizedEdgeFromNormals< PointT, PointNT, PointLT > |
pcl::OrganizedEdgeFromRGBNormals< PointT, PointNT, PointLT > |
pcl::OrganizedEdgeFromRGB< PointT, PointLT > |
pcl::OrganizedEdgeFromRGBNormals< PointT, PointNT, PointLT > |
pcl::OrganizedMultiPlaneSegmentation< PointT, PointNT, PointLT > | OrganizedMultiPlaneSegmentation finds all planes present in the input cloud, and outputs a vector of plane equations, as well as a vector of point clouds corresponding to the inliers of each detected plane
pcl::PCA< PointT > | Principal Component analysis (PCA) class
pcl::ProgressiveMorphologicalFilter< PointT > | Implements the Progressive Morphological Filter for segmentation of ground points
pcl::RegionGrowing< PointT, NormalT > | Implements the well known Region Growing algorithm used for segmentation
pcl::RegionGrowingRGB< PointT, NormalT > | Implements the well known Region Growing algorithm used for segmentation based on color of points
pcl::registration::ELCH< PointT > | ELCH (Explicit Loop Closing Heuristic) class
pcl::SACSegmentation< PointT > | SACSegmentation represents the Nodelet segmentation class for Sample Consensus methods and models, in the sense that it just creates a Nodelet wrapper for generic-purpose SAC-based segmentation
pcl::SACSegmentationFromNormals< PointT, PointNT > | SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and models that require the use of surface normals for estimation
pcl::SegmentDifferences< PointT > | SegmentDifferences obtains the difference between two spatially aligned point clouds and returns the difference between them for a maximum given distance threshold
pcl::StatisticalMultiscaleInterestRegionExtraction< PointT > | Class for extracting interest regions from unstructured point clouds, based on a multi scale statistical approach
pcl::SupervoxelClustering< PointT > | Implements a supervoxel algorithm based on voxel structure, normals, and rgb values
pcl::SurfelSmoothing< PointT, PointNT > |
pcl::Registration< PointT, PointT > |
pcl::Registration< PointT, PointT, Scalar > |
pcl::PCLBase< NormalT > |
pcl::Filter< NormalT > |
pcl::NormalRefinement< NormalT > | Normal vector refinement class
pcl::PCLBase< pcl::PCLPointCloud2 > |
pcl::Filter< pcl::PCLPointCloud2 > | Filter represents the base filter class
pcl::FilterIndices< pcl::PCLPointCloud2 > | FilterIndices represents the base class for filters that are about binary point removal
pcl::CropBox< pcl::PCLPointCloud2 > | CropBox is a filter that allows the user to filter all the data inside of a given box
pcl::ExtractIndices< pcl::PCLPointCloud2 > | ExtractIndices extracts a set of indices from a point cloud
pcl::PassThrough< pcl::PCLPointCloud2 > | PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints
pcl::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
pcl::RandomSample< pcl::PCLPointCloud2 > | RandomSample applies a random sampling with uniform probability
pcl::StatisticalOutlierRemoval< pcl::PCLPointCloud2 > | StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data
pcl::ProjectInliers< pcl::PCLPointCloud2 > | ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud
pcl::VoxelGrid< pcl::PCLPointCloud2 > | VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::PCLBase< pcl::PointXYZ > |
pcl::Keypoint< pcl::PointXYZ, pcl::PointUV > |
pcl::AgastKeypoint2DBase< pcl::PointXYZ, pcl::PointUV, pcl::common::IntensityFieldAccessor< pcl::PointXYZ > > |
pcl::AgastKeypoint2D< pcl::PointXYZ, pcl::PointUV > | Detects 2D AGAST corner points
pcl::PCLBase< pcl::PointXYZRGB > |
pcl::Filter< pcl::PointXYZRGB > |
pcl::VoxelGrid< pcl::PointXYZRGB > |
pcl::PCLBase< pcl::PointXYZRGBA > |
pcl::Feature< pcl::PointXYZRGBA, pcl::Normal > |
pcl::IntegralImageNormalEstimation< pcl::PointXYZRGBA, pcl::Normal > |
pcl::OrganizedMultiPlaneSegmentation< pcl::PointXYZRGBA, pcl::Normal, pcl::Label > |
pcl::PCLBase< pcl::PointXYZRGBL > |
pcl::Filter< pcl::PointXYZRGBL > |
pcl::VoxelGrid< pcl::PointXYZRGBL > |
pcl::VoxelGridLabel |
pcl::PCLBase< PointFeature > |
pcl::PyramidFeatureHistogram< PointFeature > | Class that compares two sets of features by using a multiscale representation of the features inside a pyramid
pcl::PCLBase< PointIn > |
pcl::filters::Convolution3D< PointIn, PointOut, KernelT > | 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
pcl::PCLBase< PointInT > |
pcl::Feature< PointInT, PointNT > |
pcl::NormalEstimation< PointInT, PointNT > |
pcl::Filter< PointInT > |
pcl::Convolution< PointInT > |
pcl::FilterIndices< PointInT > |
pcl::PassThrough< PointInT > |
pcl::CloudSurfaceProcessing< PointInT, PointOutT > | 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
pcl::BilateralUpsampling< PointInT, PointOutT > | Bilateral filtering implementation, based on the following paper:
pcl::MovingLeastSquares< PointInT, PointOutT > | MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm for data smoothing and improved normal estimation
pcl::ColorGradientDOTModality< PointInT > |
pcl::ColorGradientModality< PointInT > | Modality based on max-RGB gradients
pcl::ColorModality< PointInT > |
pcl::Feature< PointInT, PointOutT > | Feature represents the base feature class
pcl::DifferenceOfNormalsEstimation< PointInT, PointNT, PointOutT > | A Difference of Normals (DoN) scale filter implementation for point cloud data
pcl::ESFEstimation< PointInT, PointOutT > | ESFEstimation estimates the ensemble of shape functions descriptors for a given point cloud dataset containing points
pcl::FeatureFromLabels< PointInT, PointLT, PointOutT > |
pcl::GFPFHEstimation< PointInT, PointLT, PointOutT > | GFPFHEstimation estimates the Global Fast Point Feature Histogram (GFPFH) descriptor for a given point cloud dataset containing points and labels
pcl::FeatureFromNormals< PointInT, PointNT, PointOutT > |
pcl::BOARDLocalReferenceFrameEstimation< PointInT, PointNT, PointOutT > | BOARDLocalReferenceFrameEstimation implements the BOrder Aware Repeatable Directions algorithm for local reference frame estimation as described here:
pcl::BoundaryEstimation< PointInT, PointNT, PointOutT > | BoundaryEstimation estimates whether a set of points is lying on surface boundaries using an angle criterion
pcl::CPPFEstimation< PointInT, PointNT, PointOutT > | Class that calculates the "surflet" features for each pair in the given pointcloud
pcl::CRHEstimation< PointInT, PointNT, PointOutT > | CRHEstimation estimates the Camera Roll Histogram (CRH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in:
pcl::CVFHEstimation< PointInT, PointNT, PointOutT > | CVFHEstimation estimates the Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given point cloud dataset containing XYZ data and normals, as presented in:
pcl::FLARELocalReferenceFrameEstimation< PointInT, PointNT, PointOutT, SignedDistanceT > | FLARELocalReferenceFrameEstimation implements the Fast LocAl Reference framE algorithm for local reference frame estimation as described here:
pcl::FPFHEstimation< PointInT, PointNT, PointOutT > | FPFHEstimation estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals
pcl::FPFHEstimationOMP< PointInT, PointNT, PointOutT > | FPFHEstimationOMP estimates the Fast Point Feature Histogram (FPFH) descriptor for a given point cloud dataset containing points and normals, in parallel, using the OpenMP standard
pcl::GRSDEstimation< PointInT, PointNT, PointOutT > | GRSDEstimation estimates the Global Radius-based Surface Descriptor (GRSD) for a given point cloud dataset containing points and normals
pcl::IntensityGradientEstimation< PointInT, PointNT, PointOutT, IntensitySelectorT > | IntensityGradientEstimation estimates the intensity gradient for a point cloud that contains position and intensity values
pcl::OURCVFHEstimation< PointInT, PointNT, PointOutT > | 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:
pcl::PFHEstimation< PointInT, PointNT, PointOutT > | PFHEstimation estimates the Point Feature Histogram (PFH) descriptor for a given point cloud dataset containing points and normals
pcl::PFHRGBEstimation< PointInT, PointNT, PointOutT > |
pcl::PPFEstimation< PointInT, PointNT, PointOutT > | Class that calculates the "surflet" features for each pair in the given pointcloud
pcl::PPFRGBEstimation< PointInT, PointNT, PointOutT > |
pcl::PPFRGBRegionEstimation< PointInT, PointNT, PointOutT > |
pcl::PrincipalCurvaturesEstimation< PointInT, PointNT, PointOutT > | PrincipalCurvaturesEstimation estimates the directions (eigenvectors) and magnitudes (eigenvalues) of principal surface curvatures for a given point cloud dataset containing points and normals
pcl::RSDEstimation< PointInT, PointNT, PointOutT > | RSDEstimation estimates the Radius-based Surface Descriptor (minimal and maximal radius of the local surface's curves) for a given point cloud dataset containing points and normals
pcl::ShapeContext3DEstimation< PointInT, PointNT, PointOutT > | ShapeContext3DEstimation implements the 3D shape context descriptor as described in:
pcl::SHOTEstimationBase< PointInT, PointNT, PointOutT, PointRFT > | SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals
pcl::VFHEstimation< PointInT, PointNT, PointOutT > | VFHEstimation estimates the Viewpoint Feature Histogram (VFH) descriptor for a given point cloud dataset containing points and normals
pcl::GASDEstimation< PointInT, PointOutT > | GASDEstimation estimates the Globally Aligned Spatial Distribution (GASD) descriptor for a given point cloud dataset given XYZ data
pcl::GASDColorEstimation< PointInT, PointOutT > | GASDColorEstimation estimates the Globally Aligned Spatial Distribution (GASD) descriptor for a given point cloud dataset given XYZ and RGB data
pcl::IntegralImageNormalEstimation< PointInT, PointOutT > | Surface normal estimation on organized data using integral images
pcl::IntensitySpinEstimation< PointInT, PointOutT > | IntensitySpinEstimation estimates the intensity-domain spin image descriptors for a given point cloud dataset containing points and intensity
pcl::LinearLeastSquaresNormalEstimation< PointInT, PointOutT > | Surface normal estimation on dense data using a least-squares estimation based on a first-order Taylor approximation
pcl::MomentInvariantsEstimation< PointInT, PointOutT > | MomentInvariantsEstimation estimates the 3 moment invariants (j1, j2, j3) at each 3D point
pcl::NormalEstimation< PointInT, PointOutT > | NormalEstimation estimates local surface properties (surface normals and curvatures)at each 3D point
pcl::NormalEstimationOMP< PointInT, PointOutT > | NormalEstimationOMP estimates local surface properties at each 3D point, such as surface normals and curvatures, in parallel, using the OpenMP standard
pcl::RIFTEstimation< PointInT, GradientT, PointOutT > | RIFTEstimation estimates the Rotation Invariant Feature Transform descriptors for a given point cloud dataset containing points and intensity
pcl::ROPSEstimation< PointInT, PointOutT > | 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
pcl::SHOTLocalReferenceFrameEstimation< PointInT, PointOutT > | SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor
pcl::SHOTLocalReferenceFrameEstimationOMP< PointInT, PointOutT > | SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor
pcl::SpinImageEstimation< PointInT, PointNT, PointOutT > | Estimates spin-image descriptors in the given input points
pcl::UniqueShapeContext< PointInT, PointOutT, PointRFT > | UniqueShapeContext implements the Unique Shape Context Descriptor described here:
pcl::Keypoint< PointInT, PointOutT > | Keypoint represents the base class for key points
pcl::AgastKeypoint2DBase< PointInT, PointOutT, pcl::common::IntensityFieldAccessor< PointInT > > |
pcl::AgastKeypoint2D< PointInT, PointOutT > | Detects 2D AGAST corner points
pcl::AgastKeypoint2DBase< PointInT, PointOutT, IntensityT > | Detects 2D AGAST corner points
pcl::BriskKeypoint2D< PointInT, PointOutT, IntensityT > | Detects BRISK interest points based on the original code and paper reference by
pcl::HarrisKeypoint2D< PointInT, PointOutT, IntensityT > | HarrisKeypoint2D detects Harris corners family points
pcl::HarrisKeypoint3D< PointInT, PointOutT, NormalT > | HarrisKeypoint3D uses the idea of 2D Harris keypoints, but instead of using image gradients, it uses surface normals
pcl::HarrisKeypoint6D< PointInT, PointOutT, NormalT > | Keypoint detector for detecting corners in 3D (XYZ), 2D (intensity) AND mixed versions of these
pcl::ISSKeypoint3D< PointInT, PointOutT, NormalT > | ISSKeypoint3D detects the Intrinsic Shape Signatures keypoints for a given point cloud
pcl::SIFTKeypoint< PointInT, PointOutT > | SIFTKeypoint detects the Scale Invariant Feature Transform keypoints for a given point cloud dataset containing points and intensity
pcl::SUSANKeypoint< PointInT, PointOutT, NormalT, IntensityT > | SUSANKeypoint implements a RGB-D extension of the SUSAN detector including normal directions variation in top of intensity variation
pcl::TrajkovicKeypoint2D< PointInT, PointOutT, IntensityT > | TrajkovicKeypoint2D implements Trajkovic and Hedley corner detector on organized pooint cloud using intensity information
pcl::TrajkovicKeypoint3D< PointInT, PointOutT, NormalT > | TrajkovicKeypoint3D implements Trajkovic and Hedley corner detector on point cloud using geometric information
pcl::PCLSurfaceBase< PointInT > | Pure abstract class
pcl::MeshConstruction< PointInT > | MeshConstruction represents a base surface reconstruction class
pcl::ConcaveHull< PointInT > | ConcaveHull (alpha shapes) using libqhull library
pcl::ConvexHull< PointInT > | ConvexHull using libqhull library
pcl::GreedyProjectionTriangulation< PointInT > | GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points based on local 2D projections
pcl::OrganizedFastMesh< PointInT > | Simple triangulation/surface reconstruction for organized point clouds
pcl::SurfaceReconstruction< PointInT > | SurfaceReconstruction represents a base surface reconstruction class
pcl::SurfaceNormalModality< PointInT > | Modality based on surface normals
pcl::tracking::Tracker< PointInT, StateT > | Tracker represents the base tracker class
pcl::tracking::ParticleFilterTracker< PointInT, StateT > | ParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
pcl::tracking::KLDAdaptiveParticleFilterTracker< PointInT, StateT > | KLDAdaptiveParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
pcl::tracking::KLDAdaptiveParticleFilterOMPTracker< PointInT, StateT > | KLDAdaptiveParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method
pcl::tracking::ParticleFilterOMPTracker< PointInT, StateT > | ParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method in parallel, using the OpenMP standard
pcl::tracking::Tracker< PointInT, Eigen::Affine3f > |
pcl::tracking::PyramidalKLTTracker< PointInT, IntensityT > | Pyramidal Kanade Lucas Tomasi tracker
pcl::PCLBase< PointModelT > |
pcl::CorrespondenceGrouping< PointModelT, PointSceneT > | Abstract base class for Correspondence Grouping algorithms
pcl::GeometricConsistencyGrouping< PointModelT, PointSceneT > | Class implementing a 3D correspondence grouping enforcing geometric consistency among feature correspondences
pcl::Hough3DGrouping< PointModelT, PointSceneT, PointModelRfT, PointSceneRfT > | Class implementing a 3D correspondence grouping algorithm that can deal with multiple instances of a model template found into a given scene
pcl::PCLBase< PointNT > |
pcl::PCLSurfaceBase< PointNT > |
pcl::SurfaceReconstruction< PointNT > |
pcl::GridProjection< PointNT > | Grid projection surface reconstruction method
pcl::MarchingCubes< PointNT > | The marching cubes surface reconstruction algorithm
pcl::MarchingCubesHoppe< PointNT > | The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance from tangent planes, proposed by Hoppe et
pcl::MarchingCubesRBF< PointNT > | The marching cubes surface reconstruction algorithm, using a signed distance function based on radial basis functions
pcl::Poisson< PointNT > | The Poisson surface reconstruction algorithm
pcl::PCLBase< PointRGBT > |
pcl::ColorGradientModality< PointRGBT > |
pcl::PCLBase< PointSource > |
pcl::Feature< PointSource, PointFeature > |
pcl::MultiscaleFeaturePersistence< PointSource, PointFeature > | Generic class for extracting the persistent features from an input point cloud It can be given any Feature estimator instance and will compute the features of the input over a multiscale representation of the cloud and output the unique ones over those scales
pcl::Registration< PointSource, PointTarget, Scalar > | Registration represents the base registration class for general purpose, ICP-like methods
pcl::IterativeClosestPoint< PointSource, PointTarget, Scalar > | IterativeClosestPoint provides a base implementation of the Iterative Closest Point algorithm
pcl::IterativeClosestPointNonLinear< PointSource, PointTarget, Scalar > | IterativeClosestPointNonLinear is an ICP variant that uses Levenberg-Marquardt optimization backend
pcl::IterativeClosestPointWithNormals< PointSource, PointTarget, Scalar > | IterativeClosestPointWithNormals is a special case of IterativeClosestPoint, that uses a transformation estimated based on Point to Plane distances by default
pcl::JointIterativeClosestPoint< PointSource, PointTarget, Scalar > | JointIterativeClosestPoint extends ICP to multiple frames which share the same transform
pcl::registration::FPCSInitialAlignment< PointSource, PointTarget, NormalT, Scalar > | 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
pcl::registration::KFPCSInitialAlignment< PointSource, PointTarget, NormalT, Scalar > | 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
pcl::registration::CorrespondenceEstimationBase< PointSource, PointTarget, Scalar > | Abstract CorrespondenceEstimationBase class
pcl::registration::CorrespondenceEstimation< PointSource, PointTarget, Scalar > | CorrespondenceEstimation represents the base class for determining correspondences between target and query point sets/features
pcl::registration::CorrespondenceEstimationBackProjection< PointSource, PointTarget, NormalT, Scalar > | CorrespondenceEstimationBackprojection computes correspondences as points in the target cloud which have minimum
pcl::registration::CorrespondenceEstimationNormalShooting< PointSource, PointTarget, NormalT, Scalar > | CorrespondenceEstimationNormalShooting computes correspondences as points in the target cloud which have minimum distance to normals computed on the input cloud
pcl::registration::CorrespondenceEstimationOrganizedProjection< PointSource, PointTarget, Scalar > | CorrespondenceEstimationOrganizedProjection computes correspondences by projecting the source point cloud onto the target point cloud using the camera intrinsic and extrinsic parameters
pcl::Registration< PointSource, PointTarget > |
pcl::NormalDistributionsTransform< PointSource, PointTarget > | A 3D Normal Distribution Transform registration implementation for point cloud data
pcl::NormalDistributionsTransform2D< PointSource, PointTarget > | NormalDistributionsTransform2D provides an implementation of the Normal Distributions Transform algorithm for scan matching
pcl::PPFRegistration< PointSource, PointTarget > | Class that registers two point clouds based on their sets of PPFSignatures
pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT > | SampleConsensusInitialAlignment is an implementation of the initial alignment algorithm described in section IV of "Fast Point Feature Histograms (FPFH) for 3D Registration," Rusu et al
pcl::SampleConsensusPrerejective< PointSource, PointTarget, FeatureT > | Pose estimation and alignment class using a prerejective RANSAC routine
pcl::Registration< PointSource, PointTarget, float > |
pcl::IterativeClosestPoint< PointSource, PointTarget > |
pcl::GeneralizedIterativeClosestPoint< PointSource, PointTarget > | GeneralizedIterativeClosestPoint is an ICP variant that implements the generalized iterative closest point algorithm as described by Alex Segal et al
pcl::PCLBase< PointTarget > |
pcl::Filter< PointTarget > |
pcl::VoxelGrid< PointTarget > |
pcl::VoxelGridCovariance< PointTarget > |
pcl::PCLBase< PointWithRange > |
pcl::Feature< PointWithRange, BorderDescription > |
pcl::RangeImageBorderExtractor | Extract obstacle borders from range images, meaning positions where there is a transition from foreground to background
pcl::Feature< PointWithRange, Narf36 > |
pcl::NarfDescriptor | Computes NARF feature descriptors for points in a range image See B
pcl::Keypoint< PointWithRange, int > |
pcl::NarfKeypoint | NARF (Normal Aligned Radial Feature) keypoints
pcl::PCLBase< PointXYZRGB > |
pcl::SeededHueSegmentation | SeededHueSegmentation
pcl::PCLBase< PointXYZT > |
pcl::SurfaceNormalModality< PointXYZT > |
PCLCUDABase |
pcl_cuda::Filter< PointCloudAOS< Device > > |
pcl_cuda::PassThrough< PointCloudAOS< Device > > |
pcl_cuda::VoxelGrid< PointCloudAOS< Device > > |
pcl_cuda::Filter< PointCloudSOA< Device > > |
pcl_cuda::PassThrough< PointCloudSOA< Device > > |
pcl_cuda::VoxelGrid< PointCloudSOA< Device > > |
pcl_cuda::Filter< CloudT > | Removes points with x, y, or z equal to NaN
pcl_cuda::PassThrough< CloudT > | PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints
pcl_cuda::VoxelGrid< CloudT > | VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data
pcl::cuda::PCLCUDABase< CloudT > | PCL base class
pcl::PCLHeader |
pcl::visualization::PCLHistogramVisualizer | PCL histogram visualizer main class
pcl::PCLImage |
pcl::visualization::PCLPlotter | PCL Plotter main class
pcl::PCLPointCloud2 |
pcl::PCLPointField |
pcl::visualization::PCLSimpleBufferVisualizer | PCL simple buffer visualizer main class
pcl::visualization::PCLVisualizer | PCL Visualizer main class
pcl::gpu::people::PeopleDetector |
pcl::Permutohedral | Implementation of a high-dimensional gaussian filtering using the permutohedral lattice
pcl::gpu::people::PersonAttribs |
pcl::people::PersonClassifier< PointT > |
pcl::people::PersonClassifier< pcl::RGB > |
pcl::people::PersonCluster< PointT > | PersonCluster represents a class for representing information about a cluster containing a person
pcl::PFHRGBSignature250 | A point structure representing the Point Feature Histogram with colors (PFHRGB)
pcl::PFHSignature125 | A point structure representing the Point Feature Histogram (PFH)
pcl::PiecewiseLinearFunction | This provides functionalities to efficiently return values for piecewise linear function
pcl::recognition::ORROctreeZProjection::Pixel |
pcl::gpu::PixelRGB | Input/output pixel format for KinfuTracker
pcl::gpu::kinfuLS::PixelRGB | Input/output pixel format for KinfuTracker
pcl::PlanarPolygon< PointT > | PlanarPolygon represents a planar (2D) polygon, potentially in a 3D space
pcl::PlanarRegion< PointT > | PlanarRegion represents a set of points that lie in a plane
pcl::PlanarPolygonFusion< PointT > | PlanarPolygonFusion takes a list of 2D planar polygons and attempts to reduce them to a minimum set that best represents the scene, based on various given comparators
pcl::io::ply::ply_parser | Class ply_parser parses a PLY file and generates appropriate atomic parsers for the body
pcl::traits::POD< PointT > |
pcl::poisson::Point3D< Real > |
pcl::poisson::Point3D< float > |
point_index_idx |
pcl::PointCloud< PointT > | PointCloud represents the base class in PCL for storing collections of 3D points
pcl::PointCloud< EdgeData > |
pcl::PointCloud< FaceData > |
pcl::PointCloud< FeatureT > |
pcl::PointCloud< float > |
pcl::PointCloud< GlobalDescriptorT > |
pcl::PointCloud< HalfEdgeData > |
pcl::PointCloud< LocalDescriptorT > |
pcl::PointCloud< ModelT > |
pcl::PointCloud< NormalT > |
pcl::PointCloud< pcl::device::prob_histogram > |
pcl::PointCloud< pcl::GradientXY > |
pcl::PointCloud< pcl::IntensityGradient > |
pcl::PointCloud< pcl::InterestPoint > |
pcl::PointCloud< pcl::Normal > |
pcl::PointCloud< pcl::PointNormal > |
pcl::PointCloud< pcl::PointUV > |
pcl::PointCloud< pcl::PointXYZ > |
pcl::PointCloud< pcl::PointXYZI > |
pcl::PointCloud< pcl::PointXYZINormal > |
pcl::PointCloud< pcl::PointXYZRGB > |
pcl::PointCloud< pcl::PointXYZRGBA > |
pcl::PointCloud< pcl::PointXYZRGBL > |
pcl::PointCloud< pcl::RGB > |
pcl::PointCloud< pcl::VFHSignature308 > |
pcl::PointCloud< PointInT > |
pcl::PointCloud< PointNT > |
pcl::PointCloud< PointOutT > |
pcl::PointCloud< PointRGBT > |
pcl::PointCloud< PointSource > |
pcl::PointCloud< PointTarget > |
pcl::PointCloud< PointWithRange > |
pcl::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

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

pcl::RangeImageSpherical | RangeImageSpherical is derived from the original range image and uses a slightly different spherical projection
pcl::PointCloud< PointXYZRGBA > |
pcl::BearingAngleImage | Class BearingAngleImage is used as an interface to generate Bearing Angle(BA) image
pcl::PointCloud< PointXYZT > |
pcl::PointCloud< RGB > |
pcl::PointCloud< SceneT > |
pcl::PointCloud< unsigned char > |
pcl::PointCloud< unsigned short > |
pcl::PointCloud< VertexData > |
pcl::cuda::PointCloudAOS< Storage > | PointCloudAOS represents an AOS (Array of Structs) PointCloud implementation for CUDA processing
pcl::tracking::PointCloudCoherence< PointInT > | PointCloudCoherence is a base class to compute coherence between the two PointClouds
pcl::tracking::NearestPairPointCloudCoherence< PointInT > | NearestPairPointCloudCoherence computes coherence between two pointclouds using the nearest point pairs
pcl::tracking::ApproxNearestPairPointCloudCoherence< PointInT > | ApproxNearestPairPointCloudCoherence computes coherence between two pointclouds using the approximate nearest point pairs
pcl::visualization::PointCloudColorHandler< PointT > | Base Handler class for PointCloud colors
pcl::visualization::PointCloudColorHandlerCustom< PointT > | Handler for predefined user colors
pcl::visualization::PointCloudColorHandlerGenericField< PointT > | Generic field handler class for colors
pcl::visualization::PointCloudColorHandlerHSVField< PointT > | HSV handler class for colors
pcl::visualization::PointCloudColorHandlerLabelField< PointT > | Label field handler class for colors
pcl::visualization::PointCloudColorHandlerRandom< PointT > | Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen)
pcl::visualization::PointCloudColorHandlerRGBAField< PointT > | RGBA handler class for colors
pcl::visualization::PointCloudColorHandlerRGBField< PointT > | RGB handler class for colors
pcl::visualization::PointCloudColorHandlerRGBHack< PointT > |
pcl::visualization::PointCloudColorHandler< pcl::PCLPointCloud2 > | Base Handler class for PointCloud colors
pcl::visualization::PointCloudColorHandlerCustom< pcl::PCLPointCloud2 > | Handler for predefined user colors
pcl::visualization::PointCloudColorHandlerGenericField< pcl::PCLPointCloud2 > | Generic field handler class for colors
pcl::visualization::PointCloudColorHandlerHSVField< pcl::PCLPointCloud2 > | HSV handler class for colors
pcl::visualization::PointCloudColorHandlerLabelField< pcl::PCLPointCloud2 > | Label field handler class for colors
pcl::visualization::PointCloudColorHandlerRandom< pcl::PCLPointCloud2 > | Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen)
pcl::visualization::PointCloudColorHandlerRGBAField< pcl::PCLPointCloud2 > | RGBA handler class for colors
pcl::visualization::PointCloudColorHandlerRGBField< pcl::PCLPointCloud2 > | RGB handler class for colors
pcl::visualization::PointCloudGeometryHandler< PointT > | Base handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandlerCustom< PointT > | Custom handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandlerSurfaceNormal< PointT > | Surface normal handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandlerXYZ< PointT > | XYZ handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandler< pcl::PCLPointCloud2 > | Base handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandlerCustom< pcl::PCLPointCloud2 > | Custom handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandlerSurfaceNormal< pcl::PCLPointCloud2 > | Surface normal handler class for PointCloud geometry
pcl::visualization::PointCloudGeometryHandlerXYZ< pcl::PCLPointCloud2 > | XYZ handler class for PointCloud geometry
pcl::io::PointCloudImageExtractor< PointT > | Base Image Extractor class for organized point clouds
pcl::io::PointCloudImageExtractorFromLabelField< PointT > | 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
pcl::io::PointCloudImageExtractorFromNormalField< PointT > | Image Extractor which uses the data present in the "normal" field
pcl::io::PointCloudImageExtractorFromRGBField< PointT > | Image Extractor which uses the data present in the "rgb" or "rgba" fields to produce a color image with rgb8 encoding
pcl::io::PointCloudImageExtractorWithScaling< PointT > | Image Extractor extension which provides functionality to apply scaling to the values extracted from a field
pcl::io::PointCloudImageExtractorFromCurvatureField< PointT > | Image Extractor which uses the data present in the "curvature" field to produce a curvature map (as a monochrome image with mono16 encoding)
pcl::io::PointCloudImageExtractorFromIntensityField< PointT > | Image Extractor which uses the data present in the "intensity" field to produce a monochrome intensity image (with mono16 encoding)
pcl::io::PointCloudImageExtractorFromZField< PointT > | Image Extractor which uses the data present in the "z" field to produce a depth map (as a monochrome image with mono16 encoding)
pcl::cuda::PointCloudSOA< Storage > | PointCloudSOA represents a SOA (Struct of Arrays) PointCloud implementation for CUDA processing
pcl::octree::PointCoding< PointT > | PointCoding class
pcl::octree::PointCoding< pcl::PointXYZRGB > |
pcl::tracking::PointCoherence< PointInT > | PointCoherence is a base class to compute coherence between the two points
pcl::tracking::DistanceCoherence< PointInT > | DistanceCoherence computes coherence between two points from the distance between them
pcl::tracking::HSVColorCoherence< PointInT > | HSVColorCoherence computes coherence between the two points from the color difference between them
pcl::tracking::NormalCoherence< PointInT > | NormalCoherence computes coherence between two points from the angle between their normals
pcl::PointDataAtOffset< PointT > | A datatype that enables type-correct comparisons
pcl::PointDataAtOffset< pcl::PointXYZRGB > |
pcl::PointIndices |
PointIntensity |
pcl::cuda::PointIterator< Storage, T > |
pcl::cuda::PointIterator< Device, T > |
pcl::cuda::PointIterator< Host, T > |
pcl::visualization::PointPickingEvent | /brief Class representing 3D point picking events
pcl::PointRepresentation< PointT > | PointRepresentation provides a set of methods for converting a point structs/object into an n-dimensional vector
pcl::PointRepresentation< FeatureT > |
pcl::PointRepresentation< FPFHSignature33 > |
pcl::DefaultFeatureRepresentation< FPFHSignature33 > |
pcl::DefaultPointRepresentation< FPFHSignature33 > |
pcl::PointRepresentation< GASDSignature512 > |
pcl::DefaultFeatureRepresentation< GASDSignature512 > |
pcl::DefaultPointRepresentation< GASDSignature512 > |
pcl::PointRepresentation< GASDSignature7992 > |
pcl::DefaultFeatureRepresentation< GASDSignature7992 > |
pcl::DefaultPointRepresentation< GASDSignature7992 > |
pcl::PointRepresentation< GASDSignature984 > |
pcl::DefaultFeatureRepresentation< GASDSignature984 > |
pcl::DefaultPointRepresentation< GASDSignature984 > |
pcl::PointRepresentation< Narf * > |
pcl::Narf::FeaturePointRepresentation |
pcl::PointRepresentation< Narf36 > |
pcl::DefaultPointRepresentation< Narf36 > |
pcl::PointRepresentation< NormalBasedSignature12 > |
pcl::DefaultFeatureRepresentation< NormalBasedSignature12 > |
pcl::DefaultPointRepresentation< NormalBasedSignature12 > |
pcl::PointRepresentation< PFHRGBSignature250 > |
pcl::DefaultFeatureRepresentation< PFHRGBSignature250 > |
pcl::DefaultPointRepresentation< PFHRGBSignature250 > |
pcl::PointRepresentation< PFHSignature125 > |
pcl::DefaultFeatureRepresentation< PFHSignature125 > |
pcl::DefaultPointRepresentation< PFHSignature125 > |
pcl::PointRepresentation< PointDefault > |
pcl::CustomPointRepresentation< PointDefault > | CustomPointRepresentation extends PointRepresentation to allow for sub-part selection on the point
pcl::DefaultFeatureRepresentation< PointDefault > | DefaulFeatureRepresentation extends PointRepresentation and is intended to be used when defining the default behavior for feature descriptor types (i.e., copy each element of each field into a float array)
pcl::DefaultPointRepresentation< PointDefault > | DefaultPointRepresentation extends PointRepresentation to define default behavior for common point types
pcl::PointRepresentation< PointFeature > |
pcl::PointRepresentation< PointNormal > |
pcl::DefaultPointRepresentation< PointNormal > |
pcl::PointRepresentation< PointTarget > |
pcl::registration::TransformationValidationEuclidean< PointSource, PointTarget, Scalar >::MyPointRepresentation | Internal point representation uses only 3D coordinates for L2
pcl::PointRepresentation< PointXYZ > |
pcl::DefaultPointRepresentation< PointXYZ > |
pcl::PointRepresentation< PointXYZI > |
pcl::DefaultPointRepresentation< PointXYZI > |
pcl::PointRepresentation< PPFSignature > |
pcl::DefaultFeatureRepresentation< PPFSignature > |
pcl::DefaultPointRepresentation< PPFSignature > |
pcl::PointRepresentation< ShapeContext1980 > |
pcl::DefaultPointRepresentation< ShapeContext1980 > |
pcl::PointRepresentation< SHOT1344 > |
pcl::DefaultPointRepresentation< SHOT1344 > |
pcl::PointRepresentation< SHOT352 > |
pcl::DefaultPointRepresentation< SHOT352 > |
pcl::PointRepresentation< UniqueShapeContext1960 > |
pcl::DefaultPointRepresentation< UniqueShapeContext1960 > |
pcl::PointRepresentation< VFHSignature308 > |
pcl::DefaultFeatureRepresentation< VFHSignature308 > |
pcl::DefaultPointRepresentation< VFHSignature308 > |
pcl::device::PointStream |
pcl::PointUV | A 2D point structure representing pixel image coordinates
pcl::PointXY | A 2D point structure representing Euclidean xy coordinates
pcl::PointXY32f | 2D point with float x- and y-coordinates
pcl::PointXY32i | 2D point with integer x- and y-coordinates
pcl::PointXYZIEdge | Point cloud containing edge information
pcl::cuda::PointXYZRGB | Default point xyz-rgb structure
pcl::PolygonMesh |
pcl::geometry::PolygonMeshTag | Tag describing the type of the mesh
pcl::poisson::Polynomial< Degree > |
pcl::PolynomialCalculationsT< real > | This provides some functionality for polynomials, like finding roots or approximating bivariate polynomials
pcl::MLSResult::PolynomialPartialDerivative | Data structure used to store the MLS polynomial partial derivatives
PolynomialSolverBase |
Eigen::PolynomialSolver< _Scalar, 2 > |
pcl::registration::PoseEstimate< PointT > | PoseEstimate struct
pcl::PosesFromMatches::PoseEstimate | A result of the pose estimation process
pcl::registration::PoseMeasurement< VertexT, InformationT > | PoseMeasurement struct
pcl::PosesFromMatches | Calculate 3D transformation based on point correspondences
pcl::PPFRegistration< PointSource, PointTarget >::PoseWithVotes | Structure for storing a pose (represented as an Eigen::Affine3f) and an integer for counting votes
pcl::PPFHashMapSearch |
pcl::PPFRGBSignature | A point structure for storing the Point Pair Color Feature (PPFRGB) values
pcl::device::PPFRGBSignature |
pcl::PPFSignature | A point structure for storing the Point Pair Feature (PPF) values
pcl::device::PPFSignature |
pcl::poisson::PPolynomial< Degree > |
pcl::poisson::PPolynomial< Degree+1 > |
pcl::poisson::PPolynomial< Degree-1 > |
pcl::device::PrincipalCurvatures |
pcl::PrincipalCurvatures | A point structure representing the principal curvatures and their magnitudes
pcl::PrincipalRadiiRSD | A point structure representing the minimum and maximum surface radii (in meters) computed using RSD
pcl::octree::OctreePointCloudSearch< PointT, LeafContainerT, BranchContainerT >::prioBranchQueueEntry | Priority queue entry for branch nodes
pcl::octree::OctreePointCloudSearch< PointT, LeafContainerT, BranchContainerT >::prioPointQueueEntry | Priority queue entry for point candidates
pcl::device::prob_histogram |
pcl::device::ProbabilityProc | Implementation Class to process probability histograms on GPU
pcl::gpu::people::ProbabilityProcessor |
pcl::gpu::PseudoConvexHull3D |
pcl::filters::Pyramid< PointT > | Pyramid constructs a multi-scale representation of an organised point cloud
QMainWindow |
PCLViewer |
PCLViewer |
pcl::geometry::QuadMeshTag | Tag describing the type of the mesh
pcl::QuantizableModality | Interface for a quantizable modality
pcl::ColorGradientModality< PointRGBT > |
pcl::ColorGradientModality< PointInT > | Modality based on max-RGB gradients
pcl::ColorModality< PointInT > |
pcl::SurfaceNormalModality< PointInT > | Modality based on surface normals
pcl::SurfaceNormalModality< PointXYZT > |
pcl::QuantizedMap |
pcl::QuantizedMultiModFeature | Feature that defines a position and quantized value in a specific modality
pcl::QuantizedNormalLookUpTable | Look-up-table for fast surface normal quantization
pcl::OrganizedNeighborSearch< PointT >::radiusSearchLoopkupEntry | radiusSearchLoopkupEntry entry for radius search lookup vector
pcl::segmentation::detail::RandomWalker< Graph, EdgeWeightMap, VertexColorMap > | Multilabel graph segmentation using random walks
pcl::gpu::kinfuLS::RayCaster | Class that performs raycasting for TSDF volume
pcl::gpu::RayCaster | Class that performs raycasting for TSDF volume
pcl::gpu::people::RDFBodyPartsDetector |
pcl::Region3D< PointT > | Region3D represents summary statistics of a 3D collection of points
pcl::PlanarRegion< PointT > | PlanarRegion represents a set of points that lie in a plane
pcl::RegionXY | Defines a region in XY-space
pcl::RegistrationVisualizer< PointSource, PointTarget > | RegistrationVisualizer represents the base class for rendering the intermediate positions occupied by the source point cloud during it's registration to the target point cloud
pcl::RegressionVarianceNode< FeatureType, LabelType > | Node for a regression trees which optimizes variance
pcl::visualization::RenWinInteract |
pcl::RFFaceDetectorTrainer |
pcl::face_detection::RFTreeNode< FeatureType > |
pcl::TexMaterial::RGB |
pcl::cuda::RGB | Default RGB structure, defined as a union over 4 chars
pcl::tracking::RGBValue |
pcl::recognition::RigidTransformSpace |
pcl::poisson::RootInfo |
pcl::recognition::RotationSpace | This is a class for a discrete representation of the rotation space based on the axis-angle representation
pcl::recognition::RotationSpaceCell |
pcl::recognition::RotationSpaceCellCreator |
pcl::recognition::RotationSpaceCreator |
runtime_error |
pcl::PCLException | A base class for all pcl exceptions which inherits from std::runtime_error
pcl::BadArgumentException | An exception that is thrown when the arguments number or type is wrong/unhandled
pcl::ComputeFailedException |
pcl::InitFailedException | An exception thrown when init can not be performed should be used in all the PCLBase class inheritants
pcl::InvalidConversionException | An exception that is thrown when a PCLPointCloud2 message cannot be converted into a PCL type
pcl::InvalidSACModelTypeException | An exception that is thrown when a sample consensus model doesn't have the correct number of samples defined in model_types.h
pcl::IOException | An exception that is thrown during an IO error (typical read/write errors)
pcl::IsNotDenseException | An exception that is thrown when a PointCloud is not dense but is attempted to be used as dense
pcl::KernelWidthTooSmallException | An exception that is thrown when the kernel size is too small
pcl::NotEnoughPointsException | An exception that is thrown when the number of correspondents is not equal to the minimum required
pcl::SolverDidntConvergeException | An exception that is thrown when the non linear solver didn't converge
pcl::UnhandledPointTypeException |
pcl::UnorganizedPointCloudException | An exception that is thrown when an organized point cloud is needed but not provided
pcl::poisson::PoissonException | A base class for all poisson exceptions which inherits from std::runtime_error
pcl::poisson::PoissonBadArgumentException | An exception that is thrown when the arguments number or type is wrong/unhandled
pcl::poisson::PoissonBadInitException | An exception that is thrown when initialization fails
pcl::poisson::PoissonOpenMPException | An exception that is thrown when something goes wrong inside an openMP for loop
pcl::SampleConsensus< T > | SampleConsensus represents the base class
SampleConsensus |
pcl_cuda::MEstimatorSampleConsensus< Storage > |
pcl::cuda::SampleConsensus< Storage > |
pcl::cuda::MultiRandomSampleConsensus< Storage > | 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
pcl::cuda::RandomSampleConsensus< Storage > | 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
pcl::SampleConsensus< PointT > |
pcl::LeastMedianSquares< PointT > | LeastMedianSquares represents an implementation of the LMedS (Least Median of Squares) algorithm
pcl::MaximumLikelihoodSampleConsensus< PointT > | MaximumLikelihoodSampleConsensus represents an implementation of the MLESAC (Maximum Likelihood Estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S
pcl::MEstimatorSampleConsensus< PointT > | MEstimatorSampleConsensus represents an implementation of the MSAC (M-estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S
pcl::ProgressiveSampleConsensus< PointT > | RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Matching with PROSAC – Progressive Sample Consensus", Chum, O
pcl::RandomizedMEstimatorSampleConsensus< PointT > | RandomizedMEstimatorSampleConsensus represents an implementation of the RMSAC (Randomized M-estimator SAmple Consensus) algorithm, which basically adds a Td,d test (see RandomizedRandomSampleConsensus) to an MSAC estimator (see MEstimatorSampleConsensus)
pcl::RandomizedRandomSampleConsensus< PointT > | RandomizedRandomSampleConsensus represents an implementation of the RRANSAC (Randomized RAndom SAmple Consensus), as described in "Randomized RANSAC with Td,d test", O
pcl::RandomSampleConsensus< PointT > | RandomSampleConsensus represents an implementation of the RANSAC (RANdom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography", Martin A
pcl::SampleConsensus< WeightSACPointType > |
pcl::SampleConsensusModel< PointT > | SampleConsensusModel represents the base model class
pcl::SampleConsensusModelCircle2D< PointT > | SampleConsensusModelCircle2D defines a model for 2D circle segmentation on the X-Y plane
pcl::SampleConsensusModelCircle3D< PointT > | SampleConsensusModelCircle3D defines a model for 3D circle segmentation
pcl::SampleConsensusModelCone< PointT, PointNT > | SampleConsensusModelCone defines a model for 3D cone segmentation
pcl::SampleConsensusModelCylinder< PointT, PointNT > | SampleConsensusModelCylinder defines a model for 3D cylinder segmentation
pcl::SampleConsensusModelLine< PointT > | SampleConsensusModelLine defines a model for 3D line segmentation
pcl::SampleConsensusModelParallelLine< PointT > | SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular constraints
pcl::SampleConsensusModelPlane< PointT > | SampleConsensusModelPlane defines a model for 3D plane segmentation
pcl::SampleConsensusModelNormalPlane< PointT, PointNT > | SampleConsensusModelNormalPlane defines a model for 3D plane segmentation using additional surface normal constraints
pcl::SampleConsensusModelNormalParallelPlane< PointT, PointNT > | SampleConsensusModelNormalParallelPlane defines a model for 3D plane segmentation using additional surface normal constraints
pcl::SampleConsensusModelParallelPlane< PointT > | SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional angular constraints
pcl::SampleConsensusModelPerpendicularPlane< PointT > | SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional angular constraints
pcl::SampleConsensusModelRegistration< PointT > | SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection
pcl::SampleConsensusModelRegistration2D< PointT > | SampleConsensusModelRegistration2D defines a model for Point-To-Point registration outlier rejection using distances between 2D pixels
pcl::SampleConsensusModelSphere< PointT > | SampleConsensusModelSphere defines a model for 3D sphere segmentation
pcl::SampleConsensusModelNormalSphere< PointT, PointNT > | SampleConsensusModelNormalSphere defines a model for 3D sphere segmentation using additional surface normal constraints
pcl::SampleConsensusModelStick< PointT > | SampleConsensusModelStick defines a model for 3D stick segmentation
pcl::cuda::SampleConsensusModel< Storage > | SampleConsensusModel represents the base model class
pcl::cuda::SampleConsensusModel1PointPlane< Storage > | SampleConsensusModel1PointPlane defines a model for 3D plane segmentation
pcl::cuda::SampleConsensusModelPlane< Storage > | SampleConsensusModelPlane defines a model for 3D plane segmentation
pcl::SampleConsensusModel< pcl::PointXYZRGB > |
pcl::SampleConsensusModelCircle2D< pcl::PointXYZRGB > |
pcl::SampleConsensusModelCircle3D< pcl::PointXYZRGB > |
pcl::SampleConsensusModelCone< pcl::PointXYZRGB, PointNT > |
pcl::SampleConsensusModelCylinder< pcl::PointXYZRGB, PointNT > |
pcl::SampleConsensusModelSphere< pcl::PointXYZRGB > |
pcl::SampleConsensusModel< PointXYZ > |
pcl::SampleConsensusModel< T > |
pcl::SampleConsensusModel< WeightSACPointType > |
pcl::SampleConsensusModelFromNormals< PointT, PointNT > | SampleConsensusModelFromNormals represents the base model class for models that require the use of surface normals for estimation
pcl::SampleConsensusModelCone< PointT, PointNT > | SampleConsensusModelCone defines a model for 3D cone segmentation
pcl::SampleConsensusModelCylinder< PointT, PointNT > | SampleConsensusModelCylinder defines a model for 3D cylinder segmentation
pcl::SampleConsensusModelNormalPlane< PointT, PointNT > | SampleConsensusModelNormalPlane defines a model for 3D plane segmentation using additional surface normal constraints
pcl::SampleConsensusModelNormalSphere< PointT, PointNT > | SampleConsensusModelNormalSphere defines a model for 3D sphere segmentation using additional surface normal constraints
pcl::SampleConsensusModelFromNormals< pcl::PointXYZRGB, PointNT > |
pcl::SampleConsensusModelCone< pcl::PointXYZRGB, PointNT > |
pcl::SampleConsensusModelCylinder< pcl::PointXYZRGB, PointNT > |
pcl::io::ply::ply_parser::scalar_property_callback_type< ScalarType > |
pcl::io::ply::ply_parser::scalar_property_callback_type< scalar_type > |
pcl::io::ply::ply_parser::scalar_property_definition_callback_type< ScalarType > |
pcl::io::ply::ply_parser::scalar_property_definition_callback_type< scalar_type > |
pcl::io::ply::ply_parser::scalar_property_definition_callbacks_type |
pcl::keypoints::brisk::ScaleSpace | BRISK Scale Space helper
Scene |
pcl::cuda::ScopeTimeCPU | Class to measure the time spent in a scope
pcl::cuda::ScopeTimeGPU | Class to measure the time spent in a scope
pcl::gpu::ScopeTimer |
pcl::keypoints::agast::AbstractAgastDetector::ScoreIndex | Structure holding an index and the associated keypoint score
pcl::kinfuLS::ScreenshotManager | Screenshot Manager saves a screenshot with the corresponding camera pose from Kinfu
pcl::search::Search< PointT > | Generic search class
pcl::search::KdTree< PointT > |
pcl::search::BruteForce< PointT > | Implementation of a simple brute force search algorithm
pcl::search::FlannSearch< PointT, FlannDistance > | search::FlannSearch is a generic FLANN wrapper class for the new search interface
pcl::search::KdTree< PointT, Tree > | search::KdTree is a wrapper class which inherits the pcl::KdTree class for performing search functions using KdTree structure
pcl::search::Octree< PointT, LeafTWrap, BranchTWrap, OctreeT > | search::Octree is a wrapper class which implements nearest neighbor search operations based on the pcl::octree::Octree structure
pcl::search::OrganizedNeighbor< PointT > | OrganizedNeighbor is a class for optimized nearest neigbhor search in organized point clouds
pcl::search::Search< pcl::PointXYZ > |
pcl::search::Search< pcl::PointXYZRGB > |
pcl::search::KdTree< pcl::PointXYZRGB > |
pcl::search::Search< PointInT > |
pcl::search::Octree< PointInT > |
pcl::search::Search< PointXYZ > |
pcl::search::Search< PointXYZRGB > |
pcl::search::Search< SceneT > |
pcl::search::KdTree< SceneT > |
pcl::search::Search< T > |
pcl::search::Search< WeightSACPointType > |
pcl::gpu::SeededHueSegmentation |
pcl::cuda::detail::SegmLink |
pcl::cuda::detail::SegmLinkVal |
pcl::recognition::ORROctreeZProjection::Set |
pcl::cuda::SetColor |
pcl::SetIfFieldExists< PointOutT, InT > | A helper functor that can set a specific value in a field if the field exists
pcl::RangeImageBorderExtractor::ShadowBorderIndices | Stores the indices of the shadow border corresponding to obstacle borders
pcl::ShapeContext1980 | A point structure representing a Shape Context
openni_wrapper::OpenNIDevice::ShiftConversion |
openni_wrapper::ShiftToDepthConverter | This class provides conversion of the openni 11-bit shift data to depth;
pcl::SHOT1344 | A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape+color
pcl::SHOT352 | A point structure representing the generic Signature of Histograms of OrienTations (SHOT) - shape only
pcl::SIFTKeypointFieldSelector< PointT > |
pcl::SIFTKeypointFieldSelector< PointInT > |
pcl::SIFTKeypointFieldSelector< PointNormal > |
pcl::SIFTKeypointFieldSelector< PointXYZRGB > |
pcl::SIFTKeypointFieldSelector< PointXYZRGBA > |
pcl::recognition::SimpleOctree< NodeData, NodeDataCreator, Scalar > |
pcl::recognition::SimpleOctree< RotationSpace, RotationSpaceCreator, float > |
pcl::recognition::SimpleOctree< RotationSpaceCell, RotationSpaceCellCreator, float > |
pcl::surface::SimplificationRemoveUnusedVertices |
ON_SerialNumberMap::SN_ELEMENT |
pcl::registration::sortCorrespondencesByDistance | sortCorrespondencesByDistance : a functor for sorting correspondences by distance
pcl::registration::sortCorrespondencesByMatchIndex | sortCorrespondencesByMatchIndex : a functor for sorting correspondences by match index
pcl::registration::sortCorrespondencesByMatchIndexAndDistance | sortCorrespondencesByMatchIndexAndDistance : a functor for sorting correspondences by match index and distance
pcl::registration::sortCorrespondencesByQueryIndex | sortCorrespondencesByQueryIndex : a functor for sorting correspondences by query index
pcl::registration::sortCorrespondencesByQueryIndexAndDistance | sortCorrespondencesByQueryIndexAndDistance : a functor for sorting correspondences by query index and distance
pcl::poisson::SortedTreeNodes |
pcl::poisson::SparseMatrix< T > |
pcl::poisson::SparseSymmetricMatrix< T > |
pcl::SparseQuantizedMultiModTemplate | A multi-modality template constructed from a set of quantized multi-modality features
pcl::gpu::people::trees::SplitPoint |
pcl::poisson::Square |
pcl::gpu::kinfuLS::StandaloneMarchingCubes< PointT > | The Standalone Marching Cubes Class provides encapsulated functionality for the Marching Cubes implementation originally by Anatoly Baksheev
pcl::poisson::StartingPolynomial< Degree > |
pcl::device::Static< expr > |
pcl::device::Static< true > |
pcl::StaticRangeCoder | StaticRangeCoder compression class
pcl::StatsEstimator< LabelDataType, NodeType, DataSet, ExampleIndex > | Class interface for gathering statistics for decision tree learning
pcl::face_detection::PoseClassRegressionVarianceStatsEstimator< LabelDataType, NodeType, DataSet, ExampleIndex > | Statistics estimator for regression trees which optimizes information gain and pose parameters error
pcl::RegressionVarianceStatsEstimator< LabelDataType, NodeType, DataSet, ExampleIndex > | Statistics estimator for regression trees which optimizes variance
pcl::StatsEstimator< LabelType, NodeType, DataSet, ExampleIndex > |
pcl::StereoMatching | Stereo Matching abstract class
pcl::GrayStereoMatching | Stereo Matching abstract class for Grayscale images
pcl::AdaptiveCostSOStereoMatching | Adaptive Cost 2-pass Scanline Optimization Stereo Matching class
pcl::BlockBasedStereoMatching | Block based (or fixed window) Stereo Matching class
pcl::StopWatch | Simple stopwatch
pcl::ScopeTime | Class to measure the time spent in a scope
pcl::cuda::StorageAllocator< Storage, T > |
pcl::cuda::StorageAllocator< Device, T > |
pcl::cuda::StorageAllocator< Host, T > |
pcl::cuda::StoragePointer< Storage, T > |
pcl::cuda::StoragePointer< Device, T > |
pcl::cuda::StoragePointer< Host, T > |
pcl::Supervoxel< PointT > | Supervoxel container class - stores a cluster extracted using supervoxel clustering
pcl::SVM | Base class for SVM SVM (Support Vector Machines)
pcl::SVMClassify | SVM (Support Vector Machines) classification of a dataset
pcl::SVMTrain | SVM (Support Vector Machines) training class for the SVM machine learning
svm_model |
pcl::SVMModel | The structure initialize a model created by the SVM (Support Vector Machines) classifier (pcl::SVMTrain)
svm_node |
svm_parameter |
pcl::SVMParam | The structure stores the parameters for the classificationa nd must be initialized and passed to the training method pcl::SVMTrain
svm_problem |
svm_scaling |
pcl::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)
pcl::SVMDataPoint | The structure initialize a single feature value for the classification using SVM (Support Vector Machines)
pcl::SynchronizedQueue< T > |
pcl::SynchronizedQueue< boost::shared_array< unsigned char > > |
pcl::SynchronizedQueue< std::uint8_t * > |
pcl::Synchronizer< T1, T2 > | /brief This template class synchronizes two data streams of different types
pcl::Synchronizer< openni_wrapper::Image::Ptr, openni_wrapper::DepthImage::Ptr > |
pcl::Synchronizer< openni_wrapper::IRImage::Ptr, openni_wrapper::DepthImage::Ptr > |
pcl::deprecated::T |
TAccPixDist< Tfrom > |
TAccPixDist< float1 > |
TAccPixDist< float3 > |
TAccPixDist< float4 > |
TAccPixDist< uchar1 > |
TAccPixDist< uchar3 > |
TAccPixDist< uchar4 > |
TAccPixDist< ushort1 > |
TAccPixDist< ushort3 > |
TAccPixDist< ushort4 > |
TAccPixWeighted< T > |
TAccPixWeighted< float1 > |
TAccPixWeighted< float3 > |
TAccPixWeighted< float4 > |
TAccPixWeighted< uchar1 > |
TAccPixWeighted< uchar3 > |
TAccPixWeighted< uchar4 > |
TAccPixWeighted< ushort1 > |
TAccPixWeighted< ushort3 > |
TAccPixWeighted< ushort4 > |
tagON_2dex |
tagON_3dex |
tagON_4dex |
tagON_RECT |
pcl::io::TARHeader | A TAR file's header, as described on http://en.wikipedia.org/wiki/Tar_%28file_format%29
TConvBase2Vec< TBase, NC > |
TConvBase2Vec< Ncv16u, 1 > |
TConvBase2Vec< Ncv16u, 3 > |
TConvBase2Vec< Ncv16u, 4 > |
TConvBase2Vec< Ncv32f, 1 > |
TConvBase2Vec< Ncv32f, 3 > |
TConvBase2Vec< Ncv32f, 4 > |
TConvBase2Vec< Ncv32u, 1 > |
TConvBase2Vec< Ncv32u, 3 > |
TConvBase2Vec< Ncv32u, 4 > |
TConvBase2Vec< Ncv64f, 1 > |
TConvBase2Vec< Ncv64f, 3 > |
TConvBase2Vec< Ncv64f, 4 > |
TConvBase2Vec< Ncv8u, 1 > |
TConvBase2Vec< Ncv8u, 3 > |
TConvBase2Vec< Ncv8u, 4 > |
TConvVec2Base< Tvec > |
TConvVec2Base< double1 > |
TConvVec2Base< double3 > |
TConvVec2Base< double4 > |
TConvVec2Base< float1 > |
TConvVec2Base< float3 > |
TConvVec2Base< float4 > |
TConvVec2Base< uchar1 > |
TConvVec2Base< uchar3 > |
TConvVec2Base< uchar4 > |
TConvVec2Base< uint1 > |
TConvVec2Base< uint3 > |
TConvVec2Base< uint4 > |
TConvVec2Base< ushort1 > |
TConvVec2Base< ushort3 > |
TConvVec2Base< ushort4 > |
pcl::ism::ImplicitShapeModelEstimation< FeatureSize, PointT, NormalT >::TermCriteria | This structure is used for determining the end of the k-means clustering process
pcl::TexMaterial |
pcl::gpu::TextureBinder |
pcl::TextureMapping< PointInT > | The texture mapping algorithm
pcl::TextureMesh |
pcl::console::TicToc |
pcl::gpu::Timer |
pcl::TimeTrigger | Timer class that invokes registered callback methods periodically
totally_ordered |
pcl::geometry::EdgeIndex | Index used to access elements in the half-edge mesh
pcl::geometry::FaceIndex | Index used to access elements in the half-edge mesh
pcl::geometry::HalfEdgeIndex | Index used to access elements in the half-edge mesh
pcl::geometry::VertexIndex | Index used to access elements in the half-edge mesh
pcl::face_detection::TrainingExample |
pcl::registration::TransformationEstimation< PointSource, PointTarget, Scalar > | TransformationEstimation represents the base class for methods for transformation estimation based on:
pcl::registration::TransformationEstimation2D< PointSource, PointTarget, Scalar > | TransformationEstimation2D implements a simple 2D rigid transformation estimation (x, y, theta) for a given pair of datasets
pcl::registration::TransformationEstimation3Point< PointSource, PointTarget, Scalar > | TransformationEstimation3Points represents the class for transformation estimation based on:
pcl::registration::TransformationEstimationDQ< PointSource, PointTarget, Scalar > | TransformationEstimationDQ implements dual quaternion based estimation of the transformation aligning the given correspondences
pcl::registration::TransformationEstimationDualQuaternion< PointSource, PointTarget, Scalar > | TransformationEstimationDualQuaternion implements dual quaternion based estimation of the transformation aligning the given correspondences
pcl::registration::TransformationEstimationPointToPlaneLLS< PointSource, PointTarget, Scalar > | TransformationEstimationPointToPlaneLLS implements a Linear Least Squares (LLS) approximation for minimizing the point-to-plane distance between two clouds of corresponding points with normals
pcl::registration::TransformationEstimationPointToPlaneLLSWeighted< PointSource, PointTarget, Scalar > | 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
pcl::registration::TransformationEstimationSVD< PointSource, PointTarget, Scalar > | TransformationEstimationSVD implements SVD-based estimation of the transformation aligning the given correspondences
pcl::registration::TransformationEstimationSVDScale< PointSource, PointTarget, Scalar > | TransformationEstimationSVD implements SVD-based estimation of the transformation aligning the given correspondences
pcl::registration::TransformationEstimationSymmetricPointToPlaneLLS< PointSource, PointTarget, Scalar > | TransformationEstimationSymmetricPointToPlaneLLS implements a Linear Least Squares (LLS) approximation for minimizing the symmetric point-to-plane distance between two clouds of corresponding points with normals
pcl::registration::TransformationEstimationLM< PointSource, PointTarget, Scalar > |
pcl::registration::TransformationEstimationPointToPlane< PointSource, PointTarget, Scalar > | TransformationEstimationPointToPlane uses Levenberg Marquardt optimization to find the transformation that minimizes the point-to-plane distance between the given correspondences
pcl::registration::TransformationEstimation< pcl::PointXYZ, pcl::PointXYZ, float > |
pcl::registration::TransformationEstimationSVD< pcl::PointXYZ, pcl::PointXYZ, float > |
pcl::recognition::TrimmedICP< pcl::PointXYZ, float > |
pcl::registration::TransformationEstimation< PointSource, PointTarget, MatScalar > |
pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar > | TransformationEstimationLM implements Levenberg Marquardt-based estimation of the transformation aligning the given correspondences
pcl::registration::TransformationEstimationPointToPlane< PointSource, PointTarget, MatScalar > |
pcl::registration::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar > | TransformationEstimationPointToPlaneWeighted uses Levenberg Marquardt optimization to find the transformation that minimizes the point-to-plane distance between the given correspondences
pcl::registration::TransformationEstimation< PointT, PointT, Scalar > |
pcl::registration::TransformationEstimationSVD< PointT, PointT, Scalar > |
pcl::recognition::TrimmedICP< PointT, Scalar > |
pcl::TransformationFromCorrespondences | Calculates a transformation based on corresponding 3D points
pcl::registration::TransformationValidation< PointSource, PointTarget, Scalar > | TransformationValidation represents the base class for methods that validate the correctness of a transformation found through TransformationEstimation
pcl::registration::TransformationValidationEuclidean< PointSource, PointTarget, Scalar > | TransformationValidationEuclidean computes an L2SQR norm between a source and target dataset
pcl::detail::Transformer< Scalar > | A helper struct to apply an SO3 or SE3 transform to a 3D point
pcl::gpu::people::Tree2 | This structure contains all parameters to describe the segmented tree
tree_desc_s |
pcl::poisson::TreeNodeData |
pcl::poisson::Triangle |
pcl::poisson::TriangleIndex |
pcl::geometry::TriangleMeshTag | Tag describing the type of the mesh
pcl::poisson::Triangulation< Real > |
pcl::poisson::TriangulationEdge |
pcl::poisson::TriangulationTriangle |
pcl::gpu::kinfuLS::tsdf_buffer | Structure to handle buffer addresses
pcl::TSDFVolume< VoxelT, WeightT > |
pcl::gpu::kinfuLS::TsdfVolume | TsdfVolume class
pcl::gpu::TsdfVolume | TsdfVolume class
pcl::io::ply::type_traits< ScalarType > |
Loki::TL::TypeAt< TList, index > |
Loki::TL::TypeAt< Typelist< Head, Tail >, 0 > |
Loki::TL::TypeAt< Typelist< Head, Tail >, i > |
Loki::Typelist< T, U > |
Ui_HelpWindow |
Ui::HelpWindow |
Ui_MainWindow |
Ui::MainWindow |
pcl::UnaryClassifier< PointT > |
pcl::common::uniform_distribution< T, T2 > | Uniform distribution dummy struct
pcl::common::uniform_distribution< T > |
pcl::common::uniform_distribution< T, std::enable_if_t< std::is_floating_point< T >::value > > | Uniform distribution float specialized
pcl::common::uniform_distribution< T, std::enable_if_t< std::is_integral< T >::value > > | Uniform distribution int specialized
pcl::common::UniformGenerator< T > | UniformGenerator class generates a random number from range [min, max] at each run picked according to a uniform distribution i.e eaach number within [min, max] has almost the same probability of being drawn
pcl::UniqueShapeContext1960 | A point structure representing a Unique Shape Context
pcl::poisson::UpSampleData |
pcl::texture_mapping::UvIndex | Structure that links a uv coordinate to its 3D point and face
pcl::ndt2d::ValueAndDerivatives< N, T > | Class to store vector value and first and second derivatives (grad vector and hessian matrix), so they can be returned easily from functions
vector |
pcl::DecisionForest< pcl::face_detection::RFTreeNode > |
pcl::DecisionForest< NodeType > | Class representing a decision forest
pcl::poisson::BSplineElements< Degree > |
pcl::poisson::Vector< T > |
pcl::VectorAverage< real, dimension > | Calculates the weighted average and the covariance matrix
pcl::geometry::Vertex | A vertex is a node in the mesh
pcl::registration::ELCH< PointT >::Vertex |
pcl::poisson::CoredMeshData2::Vertex |
pcl::poisson::VertexData |
pcl::registration::LUM< PointT >::VertexProperties |
pcl::Vertices | Describes a set of vertices in a polygon mesh, by basically storing an array of indices
pcl::device::VFHEstimationImpl |
pcl::VFHSignature308 | A point structure representing the Viewpoint Feature Histogram (VFH)
Viewport |
pcl::ism::ImplicitShapeModelEstimation< FeatureSize, PointT, NormalT >::VisualWordStat | Structure for storing the visual word
pcl::SupervoxelClustering< PointT >::VoxelData | VoxelData is a structure used for storing data within a pcl::octree::OctreePointCloudAdjacencyContainer
pcl::recognition::VoxelStructure< T, REAL > | This class is a box in R3 built of voxels ordered in a regular rectangular grid
pcl::recognition::VoxelStructure< HashTableCell, float > |
vtkCommand |
pcl::visualization::ImageViewer::ExitCallback |
pcl::visualization::ImageViewer::ExitMainLoopTimerCallback |
pcl::visualization::PointPickingCallback |
pcl::visualization::Window::ExitCallback |
pcl::visualization::Window::ExitMainLoopTimerCallback |
vtkContextItem |
pcl::visualization::PCLContextImageItem | Struct PCLContextImageItem a specification of vtkContextItem, used to add an image to the scene in the ImageViewer class
pcl::visualization::PCLContextItem | Struct PCLContextItem represents our own custom version of vtkContextItem, used by the ImageViewer class
pcl::visualization::context_items::Circle |
pcl::visualization::context_items::Disk |
pcl::visualization::context_items::Line |
pcl::visualization::context_items::Point |
pcl::visualization::context_items::Points |
pcl::visualization::context_items::Markers |
pcl::visualization::context_items::Polygon |
pcl::visualization::context_items::Rectangle |
pcl::visualization::context_items::FilledRectangle |
pcl::visualization::context_items::Text |
pcl::visualization::PCLPainter2D | PCL Painter2D main class
vtkImageCanvasSource2D |
pcl::visualization::PCLImageCanvasSource2D | PCLImageCanvasSource2D represents our own custom version of vtkImageCanvasSource2D, used by the ImageViewer class
vtkInteractorStyleImage |
pcl::visualization::ImageViewerInteractorStyle | An image viewer interactor style, tailored for ImageViewer
vtkInteractorStyleRubberBandPick |
pcl::visualization::PCLVisualizerInteractorStyle | PCLVisualizerInteractorStyle defines an unique, custom VTK based interactory style for PCL Visualizer applications
vtkInteractorStyleTrackballCamera |
pcl::visualization::PCLHistogramVisualizerInteractorStyle | PCL histogram visualizer interactory style class
vtkMapper |
vtkVertexBufferObjectMapper |
vtkObject |
vtkVertexBufferObject |
vtkSmartPointer< T > |
vtkSmartPointer< ExitCallback > |
vtkSmartPointer< ExitMainLoopTimerCallback > |
vtkSmartPointer< FPSCallback > |
vtkSmartPointer< pcl::visualization::ImageViewer::ExitCallback > |
vtkSmartPointer< pcl::visualization::ImageViewer::ExitMainLoopTimerCallback > |
vtkSmartPointer< pcl::visualization::ImageViewerInteractorStyle > |
vtkSmartPointer< pcl::visualization::PCLVisualizerInteractorStyle > |
vtkSmartPointer< pcl::visualization::PointPickingCallback > |
vtkSmartPointer< pcl::visualization::Window::ExitCallback > |
vtkSmartPointer< pcl::visualization::Window::ExitMainLoopTimerCallback > |
vtkSmartPointer< vtkActor > |
vtkSmartPointer< vtkActorCollection > |
vtkSmartPointer< vtkAxes > |
vtkSmartPointer< vtkCallbackCommand > |
vtkSmartPointer< vtkCamera > |
vtkSmartPointer< vtkCameraActor > |
vtkSmartPointer< vtkChartXY > |
vtkSmartPointer< vtkColorSeries > |
vtkSmartPointer< vtkContextActor > |
vtkSmartPointer< vtkContextView > |
vtkSmartPointer< vtkIdTypeArray > |
vtkSmartPointer< vtkImageData > |
vtkSmartPointer< vtkImageFlip > |
vtkSmartPointer< vtkImageSlice > |
vtkSmartPointer< vtkImageViewer > |
vtkSmartPointer< vtkInteractorStyleTrackballCamera > |
vtkSmartPointer< vtkLegendScaleActor > |
vtkSmartPointer< vtkLODActor > |
vtkSmartPointer< vtkMatrix4x4 > |
vtkSmartPointer< vtkOrientationMarkerWidget > |
vtkSmartPointer< vtkPNGWriter > |
vtkSmartPointer< vtkPointPicker > |
vtkSmartPointer< vtkPolyData > |
vtkSmartPointer< vtkRectilinearGrid > |
vtkSmartPointer< vtkRenderer > |
vtkSmartPointer< vtkRendererCollection > |
vtkSmartPointer< vtkRenderWindow > |
vtkSmartPointer< vtkRenderWindowInteractor > |
vtkSmartPointer< vtkScalarBarActor > |
vtkSmartPointer< vtkShaderProgram2 > |
vtkSmartPointer< vtkTextActor > |
vtkSmartPointer< vtkWindowToImageFilter > |
vtkSmartPointer< vtkXYPlotActor > |
pcl::VTKUtils |
pcl::device::Warp |
pcl::device::kinfuLS::Warp |
pcl::registration::WarpPointRigid< PointSourceT, PointTargetT, Scalar > | Base warp point class
pcl::registration::WarpPointRigid3D< PointSourceT, PointTargetT, Scalar > | WarpPointRigid3D enables 3D (1D rotation + 2D translation) transformations for points
pcl::registration::WarpPointRigid6D< PointSourceT, PointTargetT, Scalar > | WarpPointRigid3D enables 6D (3D rotation + 3D translation) transformations for points
pcl::registration::WarpPointRigid< PointSource, PointTarget, MatScalar > |
pcl::registration::WarpPointRigid< PointSource, PointTarget, Scalar > |
pcl::visualization::Window |
pcl::kinfuLS::WorldModel< PointT > | WorldModel maintains a 3D point cloud that can be queried and updated via helper functions
pcl::kinfuLS::WorldModel< pcl::PointXYZI > |
pcl::xNdCopyEigenPointFunctor< PointT > | Helper functor structure for copying data between an Eigen::VectorXf and a PointT
pcl::xNdCopyPointEigenFunctor< PointT > | Helper functor structure for copying data between an Eigen::VectorXf and a PointT
pcl::cuda::YUV2RGB< Storage > |
pcl::cuda::YUV2RGBKernel< Storage > |
z_stream_s |
pcl::occlusion_reasoning::ZBuffering< ModelT, SceneT > | Class to reason about occlusions
plus |
pcl::device::plusWeighted< T, W > |
unary_function |
pcl::device::bit_not< T > |