Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

pcl::_Axis | |

pcl::_Intensity | |

pcl::_Intensity32u | |

pcl::_Intensity8u | |

pcl::_Normal | |

pcl::tracking::_ParticleXYR | |

pcl::tracking::_ParticleXYRP | |

pcl::tracking::_ParticleXYRPY | |

pcl::tracking::_ParticleXYZR | |

pcl::tracking::_ParticleXYZRPY | |

pcl::ihs::_PointIHS | |

pcl::_PointNormal | |

pcl::_PointSurfel | |

pcl::_PointWithRange | |

pcl::_PointWithScale | |

pcl::_PointWithViewpoint | |

pcl::_PointXYZ | |

pcl::_PointXYZHSV | |

pcl::_PointXYZI | A point structure representing Euclidean xyz coordinates, and the intensity value |

pcl::_PointXYZINormal | |

pcl::_PointXYZL | |

pcl::_PointXYZRGB | |

pcl::_PointXYZRGBA | |

pcl::_PointXYZRGBL | |

pcl::_PointXYZRGBNormal | |

pcl::_ReferenceFrame | A structure representing the Local Reference Frame of a point |

pcl::_RGB | |

mets::abstract_cooling_schedule | Cooling criteria (for Simulated Annealing) |

mets::abstract_search< move_manager_type > | An abstract search |

pcl::keypoints::agast::AbstractAgastDetector | Abstract detector class for AGAST corner point detectors |

pcl::modeler::AbstractItem | |

AbstractMetadata | Abstract interface for outofcore metadata file types |

pcl::cloud_composer::AbstractTool | |

pcl::modeler::AbstractWorker | |

pcl::cloud_composer::ActionPair | |

pcl::AdaptiveRangeCoder | AdaptiveRangeCoder compression class |

std::tr1::gtest_internal::AddRef< T > | |

std::tr1::gtest_internal::AddRef< T & > | |

testing::internal::AddReference< T > | |

testing::internal::AddReference< T & > | |

pcl::poisson::Octree< Degree >::AdjacencyCountFunction | |

pcl::poisson::OctNode< NodeData, Real >::AdjacencyCountFunction | |

pcl::poisson::Octree< Degree >::AdjacencySetFunction | |

pcl::keypoints::internal::AgastApplyNonMaxSuppresion< Out > | |

pcl::keypoints::internal::AgastApplyNonMaxSuppresion< pcl::PointUV > | |

AGASTDemo< PointT > | |

pcl::keypoints::internal::AgastDetector< Out > | |

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::internal::AgastDetector< pcl::PointUV > | |

pcl::AgastKeypoint2D< PointInT, PointOutT > | Detects 2D AGAST corner points. Based on the original work and paper reference by |

pcl::AgastKeypoint2D< pcl::PointXYZ, pcl::PointUV > | Detects 2D AGAST corner points. Based on the original work and paper reference by |

pcl::AgastKeypoint2DBase< PointInT, PointOutT, IntensityT > | Detects 2D AGAST corner points. Based on the original work and paper reference by |

pcl::poisson::Allocator< T > | |

pcl::poisson::AllocatorState | |

pcl::ApproximateVoxelGrid< PointT > | ApproximateVoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data |

pcl::tracking::ApproxNearestPairPointCloudCoherence< PointInT > | ApproxNearestPairPointCloudCoherence computes coherence between two pointclouds using the approximate nearest point pairs |

pcl::visualization::AreaPickingEvent | |

pcl::FastBilateralFilter< PointT >::Array3D | |

pcl::ASCIIReader | Ascii Point Cloud Reader. Read any ASCII file by setting the separating characters and input point fields |

pcl::traits::asEnum< T > | |

pcl::traits::asEnum< double > | |

pcl::traits::asEnum< float > | |

pcl::traits::asEnum< int16_t > | |

pcl::traits::asEnum< int32_t > | |

pcl::traits::asEnum< int8_t > | |

pcl::traits::asEnum< uint16_t > | |

pcl::traits::asEnum< uint32_t > | |

pcl::traits::asEnum< uint8_t > | |

mets::aspiration_criteria_chain | Function object expressing an aspiration criteria |

testing::internal::AssertHelper | |

testing::internal::AssertHelper::AssertHelperData | |

testing::AssertionResult | |

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

Axes | |

pcl::Axis | A point structure representing an Axis using its normal coordinates. (SSE friendly) |

pcl::cloud_composer::BackgroundDelegate | |

mets::best_ever_criteria | Aspiration criteria implementation |

mets::best_ever_solution | The best ever solution recorder can be used as a simple solution recorder that just records the best copyable solution found during its lifetime |

BFGS< FunctorType > | |

BFGSDummyFunctor< _Scalar, NX > | |

pcl::BilateralFilter< PointT > | A bilateral filter implementation for point cloud data. Uses the intensity data channel |

pcl::BilateralUpsampling< PointInT, PointOutT > | Bilateral filtering implementation, based on the following paper: * Kopf, Johannes and Cohen, Michael F. and Lischinski, Dani and Uyttendaele, Matt - Joint Bilateral Upsampling, * ACM Transations in Graphics, July 2007 |

pcl::poisson::BinaryNode< Real > | |

pcl::BivariatePolynomialT< real > | This represents a bivariate polynomial and provides some functionality for it |

ON_RTreeMemPool::Blk | |

pcl::BOARDLocalReferenceFrameEstimation< PointInT, PointNT, PointOutT > | BOARDLocalReferenceFrameEstimation implements the BOrder Aware Repeatable Directions algorithm for local reference frame estimation as described here: |

testing::internal::bool_constant< bool_value > | |

pcl::modeler::BoolParameter | |

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::BoundaryEstimation< PointInT, PointNT, PointOutT > | BoundaryEstimation estimates whether a set of points is lying on surface boundaries using an angle criterion. The code makes use of the estimated surface normals at each point in the input dataset |

pcl::recognition::BVH< UserData >::BoundedObject | |

pcl::BoundingBoxXYZ | |

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::ihs::OpenGLViewer::BoxCoefficients | Coefficients for the wireframe box |

pcl::segmentation::grabcut::BoykovKolmogorov | |

pcl::search::BruteForce< PointT > | Implementation of a simple brute force search algorithm |

pcl::poisson::BSplineData< Degree, Real >::BSplineComponents | |

pcl::poisson::BSplineData< Degree, Real > | |

pcl::poisson::BSplineElementCoefficients< Degree > | |

pcl::poisson::BSplineElements< Degree > | |

Buffer | |

BufferAndSize | |

pcl::octree::BufferedBranchNode< ContainerT > | |

pcl::recognition::BVH< UserData > | This class is an implementation of bounding volume hierarchies. Use the build method to construct the data structure. To use the class, construct an std::vector of pointers to BVH::BoundedObject objects and pass it to the build method. BVH::BoundedObject is a template class, so you can save user-defined data in it |

std::tr1::gtest_internal::ByRef< T > | |

std::tr1::gtest_internal::ByRef< T & > | |

callback_args | |

CallbackParameters | |

pcl::io::ply::ply_parser::scalar_property_definition_callbacks_type::callbacks_element< T > | |

pcl::io::ply::ply_parser::list_property_definition_callbacks_type::callbacks_element< T > | |

Camera | |

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 |

pcl::apps::RenderViewsTesselatedSphere::camPosConstraintsAllTrue | |

pcl::ColorGradientDOTModality< PointInT >::Candidate | |

pcl::ColorModality< PointInT >::Candidate | |

pcl::ColorGradientModality< PointInT >::Candidate | Candidate for a feature (used in feature extraction methods) |

pcl::SurfaceNormalModality< PointInT >::Candidate | Candidate for a feature (used in feature extraction methods) |

pcl::modeler::ChannelActorItem | |

pcl::visualization::context_items::Circle | |

cJSON | |

cJSON_Hooks | |

mesh_circulators.Class | |

pcl::cloud_composer::ClickTrackballStyleInteractor | |

pcl::Clipper3D< PointT > | Base class for 3D clipper objects |

mets::clonable | An interface for prototype objects |

pcl::on_nurbs::ClosingBoundary | Functions for finding the common boundary of adjacent NURBS patches |

Cloud | A wrapper which allows to use any implementation of cloud provided by a third-party library |

cloud_point_index_idx | |

pcl::cloud_show< CloudT > | |

pcl::cloud_show_base | |

pcl::visualization::CloudActor | |

pcl::cloud_composer::CloudBrowser | |

pcl::cloud_composer::CloudCommand | |

pcl::cloud_composer::CloudComposerItem | |

OutofcoreCloud::CloudDataCacheItem | |

CloudEditorWidget | Class declaration for the widget for editing and viewing point clouds |

pcl::apps::optronic_viewer::CloudFilter | Interface for a class that implements a filter for a point cloud |

pcl::apps::optronic_viewer::CloudFilterFactory | Factory class to create a filter |

pcl::apps::optronic_viewer::CloudFilterFactory2< T, name > | Helper class for the factory to simplify implementation of new cloud filters. This class makes the implementation of a separate factory class obsolete, e.g.: |

pcl::common::CloudGenerator< PointT, GeneratorT > | |

pcl::common::CloudGenerator< pcl::PointXY, GeneratorT > | |

pcl::cloud_composer::CloudItem | |

pcl::CloudIterator< PointT > | Iterator class for point clouds with or without given indices |

pcl::modeler::CloudMesh | |

pcl::modeler::CloudMeshItem | |

pcl::modeler::CloudMeshItemUpdater | |

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. These types of algorithms include surface smoothing, hole filling, cloud upsampling etc |

CloudTransformTool | The cloud transform tool computes the transform matrix from user's mouse operation. It then updates the cloud with the new transform matrices to make the cloud be rendered appropriately |

pcl::cloud_composer::CloudView | View class for displaying ProjectModel data using PCLVisualizer |

pcl::cloud_composer::CloudViewer | Tabbed widget for containing CloudView widgets |

pcl::visualization::CloudViewer | Simple point cloud visualization class |

pcl::visualization::CloudViewer::CloudViewer_impl | |

CMyBrepIsSolidSetter | |

code | |

pcl::segmentation::grabcut::Color | Structure to save RGB colors into floats |

pcl::octree::ColorCoding< PointT > | ColorCoding class |

pcl::ColorGradientDOTModality< PointInT > | |

pcl::ColorGradientModality< PointInT > | Modality based on max-RGB gradients |

pcl::ColorModality< PointInT > | |

pcl::modeler::ColorParameter | |

Command | The abstract parent class of all the command classes. Commands are non-copyable |

CommandQueue | A structure for managing commands |

pcl::Comparator< PointT > | Comparator is the base class for comparators that compare two points given some function. Currently intended for use with OrganizedConnectedComponentSegmentation |

pcl::search::Search< PointT >::Compare | |

pcl::SamplingSurfaceNormal< PointT >::CompareDim | CompareDim is a comparator object for sorting across a specific dimenstion (i,.e X, Y or Z) |

pcl::keypoints::agast::AbstractAgastDetector::CompareScoreIndex | Score index comparator |

pcl::ComparisonBase< PointT > | The (abstract) base class for the comparison object |

testing::internal::CompileAssert< bool > | |

testing::internal::CompileAssertTypesEqual< T, T > | |

pcl::cloud_composer::ComposerMainWindow | MainWindow of cloud_composer application |

pcl::io::CompressionPointTraits< PointT > | |

pcl::io::CompressionPointTraits< PointXYZRGB > | |

pcl::io::CompressionPointTraits< PointXYZRGBA > | |

pcl::ihs::OfflineIntegration::ComputationFPS | Helper object for the computation thread. Please have a look at the documentation of calcFPS |

pcl::ihs::InHandScanner::ComputationFPS | Helper object for the computation thread. Please have a look at the documentation of calcFPS |

pcl::ComputeFailedException | |

pcl::ConditionalEuclideanClustering< PointT > | ConditionalEuclideanClustering performs segmentation based on Euclidean distance and a user-defined clustering condition |

pcl::ConditionalRemoval< PointT > | ConditionalRemoval filters data that satisfies certain conditions |

pcl::ConditionAnd< PointT > | AND condition |

pcl::ConditionBase< PointT > | Base condition class |

pcl::ConditionOr< PointT > | OR condition |

ConditionThresholdHSV< PointT > | |

config_s | |

pcl::io::configurationProfile_t | |

pcl::cloud_composer::SignalMultiplexer::Connection | |

testing::internal::ConstCharPtr | |

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

Consumer< PointT > | |

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::filters::Convolution< PointIn, PointOut > | |

pcl::filters::Convolution3D< PointIn, PointOut, KernelT > | |

pcl::filters::ConvolvingKernel< PointInT, PointOutT > | Class ConvolvingKernel base class for all convolving kernels |

pcl::filters::ConvolvingKernel< PointT, pcl::Normal > | |

pcl::filters::ConvolvingKernel< PointT, pcl::PointXY > | |

mets::copyable | An interface for copyable objects |

CopyBuffer | Buffer holding the points being copied and a set of operations for manipulating the buffer |

CopyCommand | |

pcl::CopyIfFieldExists< PointInT, OutT > | A helper functor that can copy a specific value if the given field exists |

pcl::poisson::CoredEdgeIndex | |

pcl::poisson::CoredFileMeshData | |

pcl::poisson::CoredFileMeshData2 | |

pcl::poisson::CoredMeshData | |

pcl::poisson::CoredMeshData2 | |

pcl::poisson::CoredPointIndex | |

pcl::poisson::CoredVectorMeshData | |

pcl::poisson::CoredVectorMeshData2 | |

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). This is represesented via the indices of a source point and a target point, and the distance between them |

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::CorrespondenceEstimationBase< PointSource, PointTarget, Scalar > | Abstract CorrespondenceEstimationBase class. All correspondence estimation methods should inherit from this |

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. The correspondences can be trimmed by a depth threshold and by a distance threshold. It is not as precise as a nearest neighbor search, but it is much faster, as it avoids the usage of any additional structures (i.e., kd-trees) |

pcl::CorrespondenceGrouping< PointModelT, PointSceneT > | Abstract base class for Correspondence Grouping algorithms |

pcl::registration::CorrespondenceRejectionOrganizedBoundary | Implements a simple correspondence rejection measure. For each pair of points in correspondence, it checks whether they are on the boundary of a silhouette. This is done by counting the number of NaN dexels in a window around the points (the threshold and window size can be set by the user) |

pcl::registration::CorrespondenceRejector | |

pcl::registration::CorrespondenceRejectorDistance | |

pcl::registration::CorrespondenceRejectorFeatures | CorrespondenceRejectorFeatures implements a correspondence rejection method based on a set of feature descriptors. Given an input feature space, the method checks if each feature in the source cloud has a correspondence in the target cloud, either by checking the first K (given) point correspondences, or by defining a tolerance threshold via a radius in feature space |

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. Correspondences with the same match index are removed and only the one with smallest distance between query and match are kept. That is, considering match->query 1-m correspondences are removed leaving only 1-1 correspondences |

pcl::registration::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. These polygons are then checked in a pose-invariant manner (i.e. the side lengths must be approximately equal), and rejection is performed by thresholding these edge lengths |

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

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

pcl::CovarianceSampling< PointT, PointNT > | Point Cloud sampling based on the 6D covariances. It selects the points such that the resulting cloud is as stable as possible for being registered (against a copy of itself) with ICP. The algorithm adds points to the resulting cloud incrementally, while trying to keep all the 6 eigenvalues of the covariance matrix as close to each other as possible. This class also comes with the computeConditionNumber method that returns a number which shows how stable a point cloud will be when used as input for ICP (the closer the value it is to 1.0, the better) |

createSHOTDesc< FeatureEstimation, PointT, NormalT, OutputT > | |

createSHOTDesc< FeatureEstimation, PointT, NormalT, SHOT1344 > | |

createSHOTDesc< FeatureEstimation, PointT, NormalT, SHOT352 > | |

createSHOTDesc< ShapeContext3DEstimation< PointT, NormalT, OutputT >, PointT, NormalT, OutputT > | |

createSHOTDesc< UniqueShapeContext< PointT, OutputT >, PointT, NormalT, OutputT > | |

pcl::CrfNormalSegmentation< PointT > | |

pcl::CRHAlignment< PointT, nbins_ > | CRHAlignment uses two Camera Roll Histograms (CRH) to find the roll rotation that aligns both views. See: |

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::CropBox< PointT > | CropBox is a filter that allows the user to filter all the data inside of a given box |

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

ct_data_s | |

pcl::poisson::Cube | |

CurveJoinEndData | |

CurveJoinSeg | |

CUserDataHeaderInfo | |

pcl::CustomPointRepresentation< PointDefault > | CustomPointRepresentation extends PointRepresentation to allow for sub-part selection on the point |

CutCommand | |

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::recognition::ORROctree::Node::Data | |

pcl::registration::DataContainer< PointT, NormalT > | |

pcl::registration::DataContainerInterface | |

pcl::traits::datatype< PointT, Tag > | |

DBLBLK | |

pcl::io::DeBayer | Various debayering methods |

pcl::traits::decomposeArray< T > | |

pcl::ConstCloudIterator< PointT >::DefaultConstIterator | |

pcl::registration::DefaultConvergenceCriteria< Scalar > | DefaultConvergenceCriteria represents an instantiation of ConvergenceCriteria, and implements the following criteria for registration loop evaluation: |

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

testing::internal::DefaultGlobalTestPartResultReporter | |

pcl::DefaultIterator< PointT > | |

pcl::geometry::DefaultMeshTraits< VertexDataT, HalfEdgeDataT, EdgeDataT, FaceDataT > | The mesh traits are used to set up compile time settings for the mesh |

testing::internal::DefaultPerThreadTestPartResultReporter | |

pcl::DefaultPointRepresentation< PointDefault > | DefaultPointRepresentation extends PointRepresentation to define default behavior for common point types |

pcl::DefaultPointRepresentation< FPFHSignature33 > | |

pcl::DefaultPointRepresentation< Narf36 > | |

pcl::DefaultPointRepresentation< NormalBasedSignature12 > | |

pcl::DefaultPointRepresentation< PFHRGBSignature250 > | |

pcl::DefaultPointRepresentation< PFHSignature125 > | |

pcl::DefaultPointRepresentation< PointNormal > | |

pcl::DefaultPointRepresentation< PointXYZ > | |

pcl::DefaultPointRepresentation< PointXYZI > | |

pcl::DefaultPointRepresentation< PPFSignature > | |

pcl::DefaultPointRepresentation< ShapeContext1980 > | |

pcl::DefaultPointRepresentation< SHOT1344 > | |

pcl::DefaultPointRepresentation< SHOT352 > | |

pcl::DefaultPointRepresentation< VFHSignature308 > | |

DeleteCommand | |

pcl::cloud_composer::DeleteItemCommand | |

DenoiseCommand | |

DenoiseParameterForm | |

pcl::DenseQuantizedMultiModTemplate | |

pcl::DenseQuantizedSingleModTemplate | |

mets::dereferenced_equal_to< Tp > | Functor class to allow hash_set of moves (used by tabu list) |

pcl::LineRGBD< PointXYZT, PointRGBT >::Detection | A LineRGBD detection |

pcl::apps::optronic_viewer::Device | |

pcl::DifferenceOfNormalsEstimation< PointInT, PointNT, PointOutT > | A Difference of Normals (DoN) scale filter implementation for point cloud data |

pcl::DinastGrabber | Grabber for DINAST devices (i.e., IPA-1002, IPA-1110, IPA-2001) |

DinastProcessor< PointType > | |

pcl::visualization::context_items::Disk | |

pcl::tracking::DistanceCoherence< PointInT > | DistanceCoherence computes coherence between two points from the distance between them. the coherence is calculated by 1 / (1 + weight * d^2 ) |

pcl::DistanceMap | Represents a distance map obtained from a distance transformation |

pcl::modeler::DockWidget | |

pcl::ihs::Dome | |

pcl::apps::DominantPlaneSegmentation< PointType > | DominantPlaneSegmentation performs euclidean segmentation on a scene assuming that a dominant plane exists |

pcl::DOTMOD | Template matching using the DOTMOD approach |

pcl::DOTModality | |

pcl::DOTMODDetection | |

pcl::GreedyProjectionTriangulation< PointInT >::doubleEdge | Struct for storing the edges starting from a fringe point |

pcl::modeler::DoubleParameter | |

Driver | |

Dummy | |

pcl::EarClipping | The ear clipping triangulation algorithm. The code is inspired by Flavien Brebion implementation, which is in n^3 and does not handle holes |

pcl::poisson::Edge | |

pcl::EdgeAwarePlaneComparator< PointT, PointNT > | EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data |

pcl::geometry::EdgeIndex | Index used to access elements in the half-edge mesh. It is basically just a wrapper around an integer with a few added methods |

pcl::poisson::EdgeIndex | |

pcl::poisson::SortedTreeNodes::EdgeIndices | |

EDGEINFO | |

pcl::registration::LUM< PointT >::EdgeProperties | |

pcl::poisson::SortedTreeNodes::EdgeTableData | |

boost::eigen_listS | |

boost::eigen_vecS | |

pcl::registration::ELCH< PointT > | ELCH (Explicit Loop Closing Heuristic) class |

pcl::io::ply::ply_parser::element | |

testing::EmptyTestEventListener | |

testing::internal::EnableIf< true > | |

pcl::EnergyMaps | Stores a set of energy maps |

pcl::search::OrganizedNeighbor< PointT >::Entry | |

pcl::recognition::RotationSpaceCell::Entry | |

pcl::search::BruteForce< PointT >::Entry | |

pcl::modeler::EnumParameter< T > | |

testing::Environment | |

testing::internal::EqHelper< lhs_is_null_literal > | |

testing::internal::EqHelper< true > | |

pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::ErrorFunctor | |

pcl::ESFEstimation< PointInT, PointOutT > | ESFEstimation estimates the ensemble of shape functions descriptors for a given point cloud dataset containing points. Shape functions are D2, D3, A3. For more information about the ESF descriptor, see: Walter Wohlkinger and Markus Vincze, "Ensemble of Shape Functions for 3D Object Classification", IEEE International Conference on Robotics and Biomimetics (IEEE-ROBIO), 2011 |

pcl::ESFSignature640 | A point structure representing the Ensemble of Shape Functions (ESF) |

pcl::EuclideanClusterComparator< PointT, PointNT, PointLT > | EuclideanClusterComparator is a comparator used for finding clusters supported by planar surfaces. This needs to be run as a second pass after extracting planar surfaces, using MultiPlaneSegmentation for example |

pcl::EuclideanClusterExtraction< PointT > | EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense |

pcl::cloud_composer::EuclideanClusteringTool | |

pcl::cloud_composer::EuclideanClusteringToolFactory | |

pcl::EuclideanPlaneCoefficientComparator< PointT, PointNT > | EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data |

mets::evaluable_solution | A copyable and evaluable solution implementation, |

EventHelper | |

pcl::visualization::PCLHistogramVisualizer::ExitCallback | |

pcl::visualization::ImageViewer::ExitCallback | |

pcl::visualization::PCLPlotter::ExitCallback | |

pcl::visualization::PCLVisualizer::ExitCallback | |

pcl::visualization::Window::ExitCallback | |

pcl::visualization::PCLHistogramVisualizer::ExitMainLoopTimerCallback | |

pcl::visualization::ImageViewer::ExitMainLoopTimerCallback | |

pcl::visualization::PCLPainter2D::ExitMainLoopTimerCallback | |

pcl::visualization::PCLPlotter::ExitMainLoopTimerCallback | |

pcl::visualization::PCLVisualizer::ExitMainLoopTimerCallback | |

pcl::visualization::Window::ExitMainLoopTimerCallback | |

mets::exponential_cooling | Original ECS proposed by Kirkpatrick |

CloudEditorWidget::ExtCompare | |

pcl::ExtractIndices< PointT > | ExtractIndices extracts a set of indices from a point cloud |

pcl::ExtractIndices< pcl::PCLPointCloud2 > | ExtractIndices extracts a set of indices from a point cloud. Usage examples: |

pcl::ExtractPolygonalPrismData< PointT > | ExtractPolygonalPrismData uses a set of point indices that represent a planar model, and together with a given height, generates a 3D polygonal prism. The polygonal prism is then used to segment all points lying inside it |

pcl::geometry::Face | A face is a closed loop of edges |

pcl::geometry::FaceAroundFaceCirculator< MeshT > | Circulates clockwise around a face and returns an index to the face of the outer half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getFaceAroundFaceCirculator () |

pcl::geometry::FaceAroundVertexCirculator< MeshT > | Circulates counter-clockwise around a vertex and returns an index to the face of the outgoing half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getFaceAroundVertexCirculator () |

pcl::poisson::Octree< Degree >::FaceEdgesFunction | |

pcl::geometry::FaceIndex | Index used to access elements in the half-edge mesh. It is basically just a wrapper around an integer with a few added methods |

pcl::ihs::detail::FaceVertexMesh | Mesh format more efficient for visualization than the half-edge data structure |

pcl::apps::optronic_viewer::FastBilateralCF | Wrapper for the fast-bilateral filter. Applies the fast- bilateral filter on a cloud for smoothing |

pcl::FastBilateralFilter< PointT > | Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper: * Sylvain Paris and FrŽdo Durand "A Fast Approximation of the Bilateral Filter using a Signal Processing Approach" European Conference on Computer Vision (ECCV'06) |

pcl::FastBilateralFilterOMP< PointT > | Implementation of a fast bilateral filter for smoothing depth information in organized point clouds Based on the following paper: * Sylvain Paris and FrÂŽdo Durand "A Fast Approximation of the Bilateral Filter using a Signal Processing Approach" European Conference on Computer Vision (ECCV'06) |

mets::feasible_solution | Interface of a feasible solution space to be searched with tabu search |

pcl::Feature< PointInT, PointOutT > | Feature represents the base feature class. Some generic 3D operations that are applicable to all features are defined here as static methods |

FeatureCloud | |

pcl::registration::CorrespondenceRejectorFeatures::FeatureContainer< FeatureT > | An inner class containing pointers to the source and target feature clouds and the parameters needed to perform the correspondence search. This class extends FeatureContainerInterface, which contains abstract methods for any methods that do not depend on the FeatureT --- these methods can thus be called from a pointer to FeatureContainerInterface without casting to the derived class |

pcl::registration::CorrespondenceRejectorFeatures::FeatureContainerInterface | |

pcl::FeatureFromLabels< PointInT, PointLT, PointOutT > | |

pcl::FeatureFromNormals< PointInT, PointNT, PointOutT > | |

pcl::Narf::FeaturePointRepresentation | |

pcl::FeatureWithLocalReferenceFrames< PointInT, PointRFT > | FeatureWithLocalReferenceFrames provides a public interface for descriptor extractor classes which need a local reference frame at each input keypoint |

pcl::visualization::FEllipticArc2D | Class for storing EllipticArc; every ellipse , circle are covered by this |

pcl::detail::FieldAdder< PointT > | |

pcl::FieldComparison< PointT > | The field-based specialization of the comparison object |

pcl::traits::fieldList< PointT > | |

pcl::detail::FieldMapper< PointT > | |

pcl::detail::FieldMapping | |

pcl::FieldMatches< PointT, Tag > | |

pcl::visualization::Figure2D | Abstract class for storing figure information. All the derived class uses the same method draw() to invoke different drawing function of vtkContext2D |

pcl::FileGrabber< PointT > | FileGrabber provides a container-style interface for grabbers which operate on fixed-size input |

testing::internal::FilePath | |

pcl::FileReader | Point Cloud Data (FILE) file format reader interface. Any (FILE) format file reader should implement its virtual methodes |

pcl::FileWriter | Point Cloud Data (FILE) file format writer. Any (FILE) format file reader should implement its virtual methodes |

pcl::visualization::context_items::FilledRectangle | |

pcl::Filter< PointT > | Filter represents the base filter class. All filters must inherit from this interface |

pcl::Filter< pcl::PCLPointCloud2 > | Filter represents the base filter class. All filters must inherit from this interface |

pcl::FilterIndices< PointT > | FilterIndices represents the base class for filters that are about binary point removal. All derived classes have to implement the filter (PointCloud &output) and the filter (std::vector<int> &indices) methods. Ideally they also make use of the negative_, keep_organized_ and extract_removed_indices_ systems. The distinguishment between the negative_ and extract_removed_indices_ systems only makes sense if the class automatically filters non-finite entries in the filtering methods (recommended) |

pcl::FilterIndices< pcl::PCLPointCloud2 > | FilterIndices represents the base class for filters that are about binary point removal. All derived classes have to implement the filter (PointCloud &output) and the filter (std::vector<int> &indices) methods. Ideally they also make use of the negative_, keep_organized_ and extract_removed_indices_ systems. The distinguishment between the negative_ and extract_removed_indices_ systems only makes sense if the class automatically filters non-finite entries in the filtering methods (recommended) |

pcl::apps::optronic_viewer::FilterWindow | Window class for wizards to create new filters |

pcl::on_nurbs::FittingCurve2d::FitParameter | |

pcl::on_nurbs::FittingCurve2dAPDM::FitParameter | |

pcl::on_nurbs::FittingCurve2dPDM::FitParameter | |

pcl::on_nurbs::FittingCurve | Fitting a 3D B-Spline curve to point-clouds using point-distance-minimization and optionally asymmetric-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingCurve2d | Fitting a 2D B-Spline curve to 2D point-clouds using point-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingCurve2dAPDM | Fitting a 2D B-Spline curve to 2D point-clouds using asymmetric point-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingCurve2dASDM | Fitting a 2D B-Spline curve to 2D point-clouds using asymmetric squared-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingCurve2dATDM | Fitting a 2D B-Spline curve to 2D point-clouds using asymmetric-tangent-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingCurve2dPDM | Fitting a 2D B-Spline curve to 2D point-clouds using point-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingCurve2dSDM | Fitting a 2D B-Spline curve to 2D point-clouds using squared-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingCurve2dTDM | Fitting a 2D B-Spline curve to 2D point-clouds using tangent-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingCylinder | Fitting a cylindric (dim 0 clamped, dim 1 periodic) B-Spline surface to 3D point-clouds using point-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingSphere | Fitting a cylindric (dim 0 clamped, dim 1 periodic) B-Spline surface to 3D point-clouds using point-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingSurface | Fitting a B-Spline surface to 3D point-clouds using point-distance-minimization Based on paper: TODO |

pcl::on_nurbs::FittingSurfaceIM | |

pcl::on_nurbs::FittingSurfaceTDM | Fitting a B-Spline surface to 3D point-clouds using tangent-distance-minimization Based on paper: TODO |

pcl::search::FlannSearch< PointT, FlannDistance >::FlannIndexCreator | Helper class that creates a FLANN index from a given FLANN matrix. To use a FLANN index type with FlannSearch, implement this interface and pass an object of the new type to the FlannSearch constructor. See the implementation of KdTreeIndexCreator for an example |

pcl::search::FlannSearch< PointT, FlannDistance > | search::FlannSearch is a generic FLANN wrapper class for the new search interface. It is able to wrap any FLANN index type, e.g. the kd tree as well as indices for high-dimensional searches and intended as a more powerful and cleaner successor to KdTreeFlann |

pcl::visualization::FloatImageUtils | |

testing::internal::FloatingPoint< RawType > | |

testing::internal::FloatingPoint< RawType >::FloatingPointUnion | |

pcl::for_each_type_impl< done > | |

pcl::for_each_type_impl< false > | |

mets::forever | |

pcl::apps::optronic_viewer::FotonicDevice | |

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::cloud_composer::FPFHEstimationTool | |

pcl::cloud_composer::FPFHEstimationToolFactory | |

pcl::cloud_composer::FPFHItem | |

pcl::FPFHSignature33 | A point structure representing the Fast Point Feature Histogram (FPFH) |

pcl::visualization::FPoints2D | Class for storing Points |

pcl::visualization::FPolygon2D | Class for Polygon |

pcl::visualization::FPolyLine2D | Class for PolyLine |

pcl::ihs::OpenGLViewer::FPS | Please have a look at the documentation of calcFPS |

pcl::visualization::PCLVisualizer::FPSCallback | |

pcl::visualization::FQuad2D | Class for storing Quads |

Frame | |

pcl::FrustumCulling< PointT > | FrustumCulling filters points inside a frustum given by pose and field of view of the camera |

pcl::poisson::FunctionData< Degree, Real > | |

pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar >::Functor< _Scalar, NX, NY > | |

pcl::registration::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar >::Functor< _Scalar, NX, NY > | |

pcl::Functor< _Scalar, NX, NY > | |

pcl::segmentation::grabcut::Gaussian | Gaussian structure |

pcl::segmentation::grabcut::GaussianFitter | |

pcl::GaussianKernel | |

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::GeneralizedIterativeClosestPoint< PointSource, PointTarget > | GeneralizedIterativeClosestPoint is an ICP variant that implements the generalized iterative closest point algorithm as described by Alex Segal et al. in http://www.stanford.edu/~avsegal/resources/papers/Generalized_ICP.pdf The approach is based on using anistropic cost functions to optimize the alignment after closest point assignments have been made. The original code uses GSL and ANN while in ours we use an eigen mapped BFGS and FLANN |

pcl::GeometricConsistencyGrouping< PointModelT, PointSceneT > | Class implementing a 3D correspondence grouping enforcing geometric consistency among feature correspondences |

Geometry | |

std::tr1::gtest_internal::Get< 0 > | |

std::tr1::gtest_internal::Get< 1 > | |

std::tr1::gtest_internal::Get< 2 > | |

std::tr1::gtest_internal::Get< 3 > | |

std::tr1::gtest_internal::Get< 4 > | |

std::tr1::gtest_internal::Get< 5 > | |

std::tr1::gtest_internal::Get< 6 > | |

std::tr1::gtest_internal::Get< 7 > | |

std::tr1::gtest_internal::Get< 8 > | |

std::tr1::gtest_internal::Get< 9 > | |

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::GFPFHSignature16 | A point structure representing the GFPFH descriptor with 16 bins |

pcl::GlobalHypothesesVerification< ModelT, SceneT > | A hypothesis verification method proposed in "A Global Hypotheses Verification Method for 3D Object Recognition", A. Aldoma and F. Tombari and L. Di Stefano and Markus Vincze, ECCV 2012 |

pcl::on_nurbs::GlobalOptimization | Fitting and optimizing multiple B-Spline surfaces to 3D point-clouds using point-distance-minimization in a single system of equations (global). Based on paper: TODO |

pcl::on_nurbs::GlobalOptimizationTDM | Fitting and optimizing multiple B-Spline surfaces to 3D point-clouds using tangent-distance-minimization (TDM) in a single system of equations (global). Based on paper: TODO |

pcl::segmentation::grabcut::GMM | |

pcl::Grabber | Grabber interface for PCL 1.x device drivers |

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::GradientXY | A point structure representing Euclidean xyz coordinates, and the intensity value |

pcl::registration::GraphHandler< GraphT > | GraphHandler class is a wrapper for a general SLAM graph The actual graph class must fulfil 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::GreedyProjectionTriangulation< PointInT > | GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points based on local 2D projections. It assumes locally smooth surfaces and relatively smooth transitions between areas with different point densities |

pcl::GreedyVerification< ModelT, SceneT > | A greedy hypothesis verification method |

Grid | |

pcl::GridProjection< PointNT > | Grid projection surface reconstruction method |

pcl::people::GroundBasedPeopleDetectionApp< PointT > | |

pcl::GroundPlaneComparator< PointT, PointNT > | GroundPlaneComparator is a Comparator for detecting smooth surfaces suitable for driving. In conjunction with OrganizedConnectedComponentSegmentation, this allows smooth groundplanes / road surfaces to be segmented from point clouds |

testing::internal::GTestFlagSaver | |

testing::internal::GTestLog | |

testing::internal::GTestMutexLock | |

gz_header_s | |

pcl::geometry::HalfEdge | An edge is a connection between two vertices. In a half-edge mesh the edge is split into two half-edges with opposite orientation. Each half-edge stores the index to the terminating vertex, the next half-edge, the previous half-edge and the face it belongs to. The opposite half-edge is accessed implicitly |

pcl::geometry::HalfEdgeIndex | Index used to access elements in the half-edge mesh. It is basically just a wrapper around an integer with a few added methods |

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 |

__gnu_cxx::hash< const long long > | |

__gnu_cxx::hash< const unsigned long long > | |

__gnu_cxx::hash< long long > | |

__gnu_cxx::hash< unsigned long long > | |

mets::hashable | An interface for hashable objects |

pcl::PPFHashMapSearch::HashKeyStruct | Data structure to hold the information for the key in the feature hash map of the PPFHashMapSearch class |

testing::internal::HasNewFatalFailureHelper | |

pcl::HDLGrabber::HDLDataPacket | |

pcl::HDLGrabber::HDLFiringData | |

pcl::HDLGrabber | Grabber for the Velodyne High-Definition-Laser (HDL) |

pcl::HDLGrabber::HDLLaserCorrection | |

pcl::HDLGrabber::HDLLaserReturn | |

pcl::ApproximateVoxelGrid< PointT >::he | |

pcl::people::HeadBasedSubclustering< PointT > | |

pcl::people::HeightMap2D< PointT > | |

pcl::DefaultFeatureRepresentation< PointDefault >::NdCopyPointFunctor::Helper< Key, FieldT, NrDims > | |

pcl::DefaultFeatureRepresentation< PointDefault >::NdCopyPointFunctor::Helper< Key, FieldT[NrDims], NrDims > | |

pcl::ihs::HelpWindow | |

pcl::Histogram< N > | A point structure representing an N-D histogram |

pcl::people::HOG | HOG represents a class for computing the HOG descriptor described in Dalal, N. and Triggs, B., "Histograms of oriented gradients for human detection", CVPR 2005 |

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. Each correspondence casts a vote for a reference point in a 3D Hough Space. The remaining 3 DOF are taken into account by associating each correspondence with a local Reference Frame. The suggested PointModelRfT is pcl::ReferenceFrame |

pcl::recognition::HoughSpace3D | HoughSpace3D is a 3D voting space. Cast votes can be interpolated in order to better deal with approximations introduced by bin quantization. A weight can also be associated with each vote |

pcl::tracking::HSVColorCoherence< PointInT > | HSVColorCoherence computes coherence between the two points from the color difference between them. the color difference is calculated in HSV color space. the coherence is calculated by 1 / ( 1 + w * (w_h^2 * h_diff^2 + w_s^2 * s_diff^2 + w_v^2 * v_diff^2)) |

pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::HuberPenalty | |

pcl::recognition::Hypothesis | |

pcl::recognition::HypothesisBase | |

pcl::recognition::ObjRecRANSAC::HypothesisCreator | |

pcl::HypothesisVerification< ModelT, SceneT > | Abstract class for hypotheses verification methods |

ICCVTutorial< FeatureType > | |

pcl::ihs::ICP | Iterative Closest Point registration |

pcl::modeler::ICPRegistrationWorker | |

pcl::ImageGrabber< PointT > | |

pcl::ImageGrabberBase | Base class for Image file grabber |

pcl::ImageGrabberBase::ImageGrabberImpl | |

pcl::visualization::ImageViewer | ImageViewer is a class for 2D image visualization |

pcl::visualization::ImageViewerInteractorStyle | An image viewer interactor style, tailored for ImageViewer |

testing::internal::ImplicitlyConvertible< From, To > | |

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. It has two main member functions. One for training, using the data for which we know which class it belongs to. And second for investigating a cloud for the presence of the class of interest. Implementation of the ISM algorithm described in "Hough Transforms and 3D SURF for robust three dimensional classication" by Jan Knopp, Mukta Prasad, Geert Willems, Radu Timofte, and Luc Van Gool |

mets::improvement_logger< neighborhood_t > | |

IncIndex | Simple functor that produces sequential integers from an initial value |

pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< MeshT > | Circulates counter-clockwise around a vertex and returns an index to the incoming half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getIncomingHalfEdgeAroundVertexCirculator () |

pcl::DefaultFeatureRepresentation< PointDefault >::IncrementFunctor | |

inflate_state | |

pcl::ihs::InHandScanner | |

pcl::InitFailedException | An exception thrown when init can not be performed should be used in all the PCLBase class inheritants |

pcl::geometry::InnerHalfEdgeAroundFaceCirculator< MeshT > | Circulates clockwise around a face and returns an index to the inner half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getInnerHalfEdgeAroundFaceCirculator () |

pcl::ihs::InputDataProcessing | Bundles methods that are applied to the input data from the sensor |

pcl::IntegralImage2D< DataType, Dimension > | Determines an integral image representation for a given organized data array |

pcl::IntegralImage2D< DataType, 1 > | Partial template specialization for integral images with just one channel |

pcl::IntegralImageNormalEstimation< PointInT, PointOutT > | Surface normal estimation on organized data using integral images |

pcl::IntegralImageTypeTraits< DataType > | |

pcl::IntegralImageTypeTraits< char > | |

pcl::IntegralImageTypeTraits< float > | |

pcl::IntegralImageTypeTraits< int > | |

pcl::IntegralImageTypeTraits< short > | |

pcl::IntegralImageTypeTraits< unsigned char > | |

pcl::IntegralImageTypeTraits< unsigned int > | |

pcl::IntegralImageTypeTraits< unsigned short > | |

pcl::ihs::Integration | Integrate several clouds into a common mesh |

pcl::Intensity | A point structure representing the grayscale intensity in single-channel images. Intensity is represented as a float value |

pcl::Intensity32u | A point structure representing the grayscale intensity in single-channel images. Intensity is represented as a uint8_t value |

pcl::Intensity8u | A point structure representing the grayscale intensity in single-channel images. Intensity is represented as a uint8_t value |

pcl::common::IntensityFieldAccessor< PointT > | |

pcl::common::IntensityFieldAccessor< pcl::PointNormal > | |

pcl::common::IntensityFieldAccessor< pcl::PointXYZ > | |

pcl::common::IntensityFieldAccessor< pcl::PointXYZRGB > | |

pcl::common::IntensityFieldAccessor< pcl::PointXYZRGBA > | |

pcl::common::IntensityFieldAccessor< pcl::PointXYZRGBL > | |

pcl::common::IntensityFieldAccessor< pcl::PointXYZRGBNormal > | |

pcl::IntensityGradient | A point structure representing the intensity gradient of an XYZI point cloud |

pcl::IntensityGradientEstimation< PointInT, PointNT, PointOutT, IntensitySelectorT > | IntensityGradientEstimation estimates the intensity gradient for a point cloud that contains position and intensity values. The intensity gradient at a given point will be a vector orthogonal to the surface normal and pointing in the direction of the greatest increase in local intensity; the vector's magnitude indicates the rate of intensity change |

pcl::IntensitySpinEstimation< PointInT, PointOutT > | IntensitySpinEstimation estimates the intensity-domain spin image descriptors for a given point cloud dataset containing points and intensity. For more information about the intensity-domain spin image descriptor, see: |

pcl::cloud_composer::InteractorStyleSwitch | |

pcl::InterestPoint | A point structure representing an interest point with Euclidean xyz coordinates, and an interest value |

internal_state | |

pcl::intersect< Sequence1, Sequence2 > | |

pcl::modeler::IntParameter | |

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 |

mets::invert_full_neighborhood | Generates a the full subsequence inversion neighborhood |

mets::invert_subsequence | A mets::mana_move that swaps a subsequence of elements in a mets::permutation_problem |

pcl::IOException | An exception that is thrown during an IO error (typical read/write errors) |

openni_wrapper::IRImage | Class containing just a reference to IR meta data |

testing::internal::is_pointer< T > | |

testing::internal::is_pointer< T * > | |

boost::detail::is_random_access< eigen_listS > | |

boost::detail::is_random_access< eigen_vecS > | |

testing::internal::IsAProtocolMessage< T > | |

pcl::PosesFromMatches::PoseEstimate::IsBetter | |

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::IsNotDenseException | An exception that is thrown when a PointCloud is not dense but is attemped to be used as dense |

pcl::ISSKeypoint3D< PointInT, PointOutT, NormalT > | ISSKeypoint3D detects the Intrinsic Shape Signatures keypoints for a given point cloud. This class is based on a particular implementation made by Federico Tombari and Samuele Salti and it has been explicitly adapted to PCL |

pcl::cloud_composer::ItemInspector | View class for displaying properties of an item |

mets::iteration_logger< neighborhood_t > | |

mets::iteration_termination_criteria | Termination criteria based on the number of iterations |

pcl::IterativeClosestPoint< PointSource, PointTarget, Scalar > | IterativeClosestPoint provides a base implementation of the Iterative Closest Point algorithm. The transformation is estimated based on Singular Value Decomposition (SVD) |

pcl::IterativeClosestPointNonLinear< PointSource, PointTarget, Scalar > | IterativeClosestPointNonLinear is an ICP variant that uses Levenberg-Marquardt optimization backend. The resultant transformation is optimized as a quaternion |

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::CloudIterator< PointT >::Iterator | |

pcl::ConstCloudIterator< PointT >::Iterator | |

pcl::IteratorIdx< PointT > | |

pcl::octree::IteratorState | |

testing::internal::IteratorTraits< Iterator > | |

testing::internal::IteratorTraits< const T * > | |

testing::internal::IteratorTraits< T * > | |

pcl::search::KdTree< PointT > | search::KdTree is a wrapper class which inherits the pcl::KdTree class for performing search functions using KdTree structure. KdTree is a generic type of 3D spatial locator using kD-tree structures. The class is making use of the FLANN (Fast Library for Approximate Nearest Neighbor) project by Marius Muja and David Lowe |

pcl::KdTree< PointT > | KdTree represents the base spatial locator class for kd-tree implementations |

pcl::KdTreeFLANN< PointT, Dist > | KdTreeFLANN is a generic type of 3D spatial locator using kD-tree structures. The class is making use of the FLANN (Fast Library for Approximate Nearest Neighbor) project by Marius Muja and David Lowe |

pcl::search::FlannSearch< PointT, FlannDistance >::KdTreeIndexCreator | Creates a FLANN KdTreeSingleIndex from the given input data |

pcl::KernelWidthTooSmallException | An exception that is thrown when the kernel size is too small |

KeyboardCallback | |

pcl::visualization::KeyboardEvent | |

pcl::Keypoint< PointInT, PointOutT > | Keypoint represents the base class for key points |

KeypointT | |

kiss_fft_cpx | |

kiss_fft_state | |

kiss_fftr_state | |

pcl::tracking::KLDAdaptiveParticleFilterOMPTracker< PointInT, StateT > | KLDAdaptiveParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method. The number of the particles changes adaptively based on KLD sampling [D. Fox, NIPS-01], [D.Fox, IJRR03]. and the computation of the weights of the particles is parallelized using OpenMP |

pcl::tracking::KLDAdaptiveParticleFilterTracker< PointInT, StateT > | KLDAdaptiveParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method. The number of the particles changes adaptively based on KLD sampling [D. Fox, NIPS-01], [D.Fox, IJRR03] |

pcl::search::FlannSearch< PointT, FlannDistance >::KMeansIndexCreator | Creates a FLANN KdTreeSingleIndex from the given input data |

pcl::Label | |

pcl::LabeledEuclideanClusterExtraction< PointT > | LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info |

pcl::visualization::ImageViewer::Layer | Internal structure describing a layer |

pcl::visualization::ImageViewer::LayerComparator | |

pcl::VoxelGridCovariance< PointT >::Leaf | Simple structure to hold a centroid, covarince and the number of points in a leaf. Inverse covariance, eigen vectors and engen values are precomputed |

pcl::UniformSampling< PointInT >::Leaf | Simple structure to hold an nD centroid and the number of points in a leaf |

pcl::GridProjection< PointNT >::Leaf | Data leaf |

pcl::MovingLeastSquares< PointInT, PointOutT >::MLSVoxelGrid::Leaf | |

pcl::LeastMedianSquares< PointT > | LeastMedianSquares represents an implementation of the LMedS (Least Median of Squares) algorithm. LMedS is a RANSAC-like model-fitting algorithm that can tolerate up to 50% outliers without requiring thresholds to be set. See Andrea Fusiello's "Elements of Geometric Computer Vision" (http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/FUSIELLO4/tutorial.html#x1-520007) for more details |

pcl::visualization::context_items::Line | |

mets::linear_cooling | Alternative LCS proposed by Randelman and Grest |

pcl::LinearizedMaps | Stores a set of linearized maps |

pcl::LinearLeastSquaresNormalEstimation< PointInT, PointOutT > | Surface normal estimation on dense data using a least-squares estimation based on a first-order Taylor approximation |

pcl::LineIterator | Organized Index Iterator for iterating over the "pixels" for a given line using the Bresenham algorithm. Supports 4 and 8 neighborhood connectivity |

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 |

testing::internal::linked_ptr< T > | |

testing::internal::linked_ptr_internal | |

pcl::io::ply::ply_parser::list_property< SizeType, ScalarType > | |

pcl::io::ply::ply_parser::list_property_begin_callback_type< SizeType, ScalarType > | |

pcl::io::ply::ply_parser::list_property_definition_callback_type< SizeType, ScalarType > | |

pcl::io::ply::ply_parser::list_property_definition_callbacks_type | |

pcl::io::ply::ply_parser::list_property_element_callback_type< SizeType, ScalarType > | |

pcl::io::ply::ply_parser::list_property_end_callback_type< SizeType, ScalarType > | |

mets::local_search< move_manager_type > | Local search algorithm |

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

pcl::registration::LUM< PointT > | Globally Consistent Scan Matching based on an algorithm by Lu and Milios |

pcl::io::LZFBayer8ImageReader | PCL-LZF 8-bit Bayer image format reader |

pcl::io::LZFBayer8ImageWriter | PCL-LZF 8-bit Bayer image format writer |

pcl::io::LZFDepth16ImageReader | PCL-LZF 16-bit depth image format reader |

pcl::io::LZFDepth16ImageWriter | PCL-LZF 16-bit depth image format writer |

pcl::io::LZFImageReader | PCL-LZF image format reader. The PCL-LZF image format is nothing else but a LZF-modified compression over an existing file type (e.g., PNG). However, in certain situations, like RGB data for example, an [RGBRGB...RGB] array will be first reordered into [RR...RGG...GBB...B] in order to ensure better compression |

pcl::io::LZFImageWriter | PCL-LZF image format writer. The PCL-LZF image format is nothing else but a LZF-modified compression over an existing file type (e.g., PNG). However, in certain situations, like RGB data for example, an [RGBRGB...RGB] array will be first reordered into [RR...RGG...GBB...B] in order to ensure better compression |

pcl::io::LZFRGB24ImageReader | PCL-LZF 24-bit RGB image format reader |

pcl::io::LZFRGB24ImageWriter | PCL-LZF 24-bit RGB image format writer |

pcl::io::LZFYUV422ImageReader | PCL-LZF 8-bit Bayer image format reader |

pcl::io::LZFYUV422ImageWriter | PCL-LZF 16-bit YUV422 image format writer |

pcl::apps::optronic_viewer::MainWindow | |

MainWindow | Class for point cloud editor |

pcl::ihs::MainWindow | |

pcl::modeler::MainWindow | |

mets::mana_move | A Mana Move is a move that can be automatically made tabu by the mets::simple_tabu_list |

mets::mana_move_hash | Functor class to allow hash_set of moves (used by tabu list) |

pcl::cloud_composer::ManipulationEvent | |

ManualRegistration | |

ON_SerialNumberMap::MAP_VALUE | |

pcl::poisson::MapReduceVector< T2 > | |

pcl::poisson::MarchingCubes | |

pcl::MarchingCubes< PointNT > | The marching cubes surface reconstruction algorithm. This is an abstract class that takes a grid and extracts the isosurface as a mesh, based on the original marching cubes paper: |

pcl::MarchingCubesHoppe< PointNT > | The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance from tangent planes, proposed by Hoppe et. al. in: Hoppe H., DeRose T., Duchamp T., MC-Donald J., Stuetzle W., "Surface reconstruction from unorganized points", SIGGRAPH '92 |

pcl::MarchingCubesRBF< PointNT > | The marching cubes surface reconstruction algorithm, using a signed distance function based on radial basis functions. Partially based on: Carr J.C., Beatson R.K., Cherrie J.B., Mitchell T.J., Fright W.R., McCallum B.C. and Evans T.R., "Reconstruction and representation of 3D objects with radial basis functions" SIGGRAPH '01 |

pcl::poisson::MarchingSquares | |

pcl::MaskMap | |

pcl::poisson::MatrixEntry< T > | |

pcl::MaximumLikelihoodSampleConsensus< PointT > | MaximumLikelihoodSampleConsensus represents an implementation of the MLESAC (Maximum Likelihood Estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to
estimating image geometry", P.H.S. Torr and A. Zisserman, Computer Vision and Image Understanding, vol 78, 2000 |

pcl::apps::optronic_viewer::MedianCF | Wrapper for a Median filter. Applies the Median filter on a cloud |

pcl::MedianFilter< PointT > | Implementation of the median filter. The median filter is one of the simplest and wide-spread image processing filters. It is known to perform well with "shot"/impulse noise (some individual pixels having extreme values), it does not reduce contrast across steps in the function (as compared to filters based on averaging), and it is robust to outliers. Furthermore, it is simple to implement and efficient, as it requires a single pass over the image. It consists of a moving window of fixed size that replaces the pixel in the center with the median inside the window |

ON_MeshTopology::memchunk | |

pcl::cloud_composer::MergeCloudCommand | |

pcl::cloud_composer::MergeCloudTool | |

pcl::cloud_composer::MergeSelection | |

Mesh | |

pcl::geometry::MeshBase< DerivedT, MeshTraitsT, MeshTagT > | Base class for the half-edge mesh |

pcl::MeshConstruction< PointInT > | MeshConstruction represents a base surface reconstruction class. All mesh constructing methods that take in a point cloud and generate a surface that uses the original data as vertices should inherit from this class |

pcl::geometry::MeshIO< MeshT > | Read / write the half-edge mesh from / to a file |

pcl::ihs::MeshProcessing | Contains methods that take advantage of the connectivity information in the mesh |

pcl::MeshProcessing | MeshProcessing represents the base class for mesh processing algorithms |

pcl::MeshQuadricDecimationVTK | PCL mesh decimation based on vtkQuadricDecimation from the VTK library. Please check out the original documentation for more details on the inner workings of the algorithm Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh data structure to the vtkPolyData data structure and back |

pcl::MeshSmoothingLaplacianVTK | PCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library. Please check out the original documentation for more details on the inner workings of the algorithm Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh data structure to the vtkPolyData data structure and back |

pcl::MeshSmoothingWindowedSincVTK | PCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library. Please check out the original documentation for more details on the inner workings of the algorithm Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh data structure to the vtkPolyData data structure and back |

pcl::MeshSubdivisionVTK | PCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library. Please check out the original documentation for more details on the inner workings of the algorithm Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh data structure to the vtkPolyData data structure and back |

MeshTraits< IsManifoldT > | |

TestMeshCirculators::MeshTraits | |

testing::Message | |

pcl::MEstimatorSampleConsensus< PointT > | MEstimatorSampleConsensus represents an implementation of the MSAC (M-estimator SAmple Consensus) algorithm, as described in: "MLESAC: A new robust estimator with application to estimating image geometry", P.H.S. Torr and A. Zisserman, Computer Vision and Image Understanding, vol 78, 2000 |

pcl::poisson::MinimalAreaTriangulation< Real > | |

pcl::MovingLeastSquares< PointInT, PointOutT >::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::recognition::ModelLibrary::Model | Stores some information about the model |

pcl::ModelCoefficients | |

pcl::GreedyVerification< ModelT, SceneT >::modelIndices | |

pcl::recognition::ModelLibrary | |

pcl::cloud_composer::ModifyItemCommand | |

pcl::cloud_composer::ModifyItemTool | |

pcl::MomentInvariants | A point structure representing the three moment invariants |

pcl::MomentInvariantsEstimation< PointInT, PointOutT > | MomentInvariantsEstimation estimates the 3 moment invariants (j1, j2, j3) at each 3D point |

MonitorQueue< DataT > | |

pcl::visualization::MouseEvent | |

mets::move | Move to be operated on a feasible solution |

pcl::GlobalHypothesesVerification< ModelT, SceneT >::move | |

mets::move_manager | A neighborhood generator |

pcl::GlobalHypothesesVerification< ModelT, SceneT >::move_manager | |

pcl::MovingLeastSquares< PointInT, PointOutT > | MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm for data smoothing and improved normal estimation. It also contains methods for upsampling the resulting cloud based on the parametric fit. Reference paper: "Computing and Rendering Point Set Surfaces" by Marc Alexa, Johannes Behr, Daniel Cohen-Or, Shachar Fleishman, David Levin and Claudio T. Silva www.sci.utah.edu/~shachar/Publications/crpss.pdf |

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

testing::internal::Mutex | |

MyPoint | |

MyPointRepresentation | |

pcl::registration::TransformationValidationEuclidean< PointSource, PointTarget, Scalar >::MyPointRepresentation | Internal point representation uses only 3D coordinates for L2 |

MyPointRepresentationXY | |

pcl::on_nurbs::FittingSurface::myvec | |

MyVertexData | |

pcl::traits::name< PointT, Tag, dummy > | |

pcl::Narf | NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data. Please refer to pcl/features/narf_descriptor.h if you want the class derived from pcl Feature. See B. Steder, R. B. Rusu, K. Konolige, and W. Burgard Point Feature Extraction on 3D Range Scans Taking into Account Object Boundaries In Proc. of the IEEE Int. Conf. on Robotics &Automation (ICRA). 2011 |

pcl::Narf36 | A point structure representing the Narf descriptor |

pcl::NarfDescriptor | |

pcl::NarfKeypoint | NARF (Normal Aligned Radial Feature) keypoints. Input is a range image, output the indices of the keypoints See B. Steder, R. B. Rusu, K. Konolige, and W. Burgard Point Feature Extraction on 3D Range Scans Taking into Account Object Boundaries In Proc. of the IEEE Int. Conf. on Robotics &Automation (ICRA). 2011 |

testing::internal::NativeArray< Element > | |

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::DefaultFeatureRepresentation< PointDefault >::NdCopyPointFunctor | |

pcl::ndt2d::NDT2D< PointT > | Build a Normal Distributions Transform of a 2D point cloud. This consists of the sum of four overlapping models of the original points with normal distributions. The value and derivatives of the model at any point can be evaluated with the test (...) function |

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::tracking::NearestPairPointCloudCoherence< PointInT > | NearestPairPointCloudCoherence computes coherence between two pointclouds using the nearest point pairs |

pcl::OrganizedConnectedComponentSegmentation< PointT, PointLT >::Neighbor | |

pcl::poisson::OctNode< NodeData, Real >::NeighborKey3 | |

pcl::poisson::OctNode< NodeData, Real >::NeighborKey5 | |

pcl::poisson::OctNode< NodeData, Real >::Neighbors3 | |

pcl::poisson::OctNode< NodeData, Real >::Neighbors5 | |

pcl::cloud_composer::NewItemCloudCommand | |

pcl::cloud_composer::NewItemTool | |

NILinemod | |

pcl::GrabCut< PointT >::NLinks | |

pcl::GreedyProjectionTriangulation< PointInT >::nnAngle | Struct for storing the angles to nearest neighbors |

pcl::NNClassification< PointT > | Nearest neighbor search based classification of PCL point type features. FLANN is used to identify a neighborhood, based on which different scoring schemes can be employed to obtain likelihood values for a specified list of classes |

mets::no_moves_error | Exception risen when some algorithm has no more moves to make |

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

mets::noimprove_termination_criteria | Termination criteria based on the number of iterations without an improvement |

pcl::Normal | A point structure representing normal coordinates and the surface curvature estimate. (SSE friendly) |

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::NormalBasedSignatureEstimation< PointT, PointNT, PointFeature > | Normal-based feature signature estimation class. Obtains the feature vector by applying Discrete Cosine and Fourier Transforms on an NxM array of real numbers representing the projection distances of the points in the input cloud to a disc around the point of interest. Please consult the following publication for more details: Xinju Li and Igor Guskov Multi-scale features for approximate alignment of point-based surfaces Proceedings of the third Eurographics symposium on Geometry processing July 2005, Vienna, Austria |

pcl::tracking::NormalCoherence< PointInT > | NormalCoherence computes coherence between two points from the angle between their normals. the coherence is calculated by 1 / (1 + weight * theta^2 ) |

pcl::ndt2d::NormalDist< PointT > | A normal distribution estimation class |

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::NormalEstimation< PointInT, PointOutT > | NormalEstimation estimates local surface properties (surface normals and curvatures)at each 3D point. If PointOutT is specified as pcl::Normal, the normal is stored in the first 3 components (0-2), and the curvature is stored in component 3 |

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

pcl::cloud_composer::NormalEstimationToolFactory | |

pcl::modeler::NormalEstimationWorker | |

pcl::common::NormalGenerator< T > | NormalGenerator class generates a random number from a normal distribution specified by (mean, sigma) |

pcl::NormalRefinement< NormalT > | Normal vector refinement class |

pcl::modeler::NormalsActorItem | |

pcl::cloud_composer::NormalsItem | |

pcl::NormalSpaceSampling< PointT, NormalT > | NormalSpaceSampling samples the input point cloud in the space of normal directions computed at every point |

pcl::NotEnoughPointsException | An exception that is thrown when the number of correspondants is not equal to the minimum required |

pcl::registration::NullEstimate | NullEstimate struct |

pcl::registration::NullMeasurement | NullMeasurement struct |

Eigen::NumTraits< pcl::ndt2d::NormalDist< PointT > > | |

pcl::on_nurbs::NurbsDataCurve | Data structure for 3D NURBS curve fitting (FittingCurve) |

pcl::on_nurbs::NurbsDataCurve2d | Data structure for 2D NURBS curve fitting (FittingCurve2d, FittingCurve2dTDM, FittingCurve2dSDM) |

pcl::on_nurbs::NurbsDataSurface | Data structure for NURBS surface fitting (FittingSurface, FittingSurfaceTDM, FittingCylinder, GlobalOptimization, GlobalOptimizationTDM) |

pcl::on_nurbs::NurbsSolve | Solving the linear system of equations using Eigen or UmfPack. (can be defined in on_nurbs.cmake) |

pcl::on_nurbs::NurbsTools | Some useful tools for initialization, point search, .. |

pcl::poisson::NVector< T, Dim > | |

pcl::keypoints::agast::OastDetector9_16 | Detector class for AGAST corner point detector (OAST 9_16) |

Object | |

ObjectFeatures | |

ObjectModel | |

ObjectRecognition | |

ObjectRecognitionParameters | |

ObjectSelection< PointT > | |

pcl::recognition::ObjRecRANSAC | This is a RANSAC-based 3D object recognition method. Do the following to use it: (i) call addModel() k times with k different models representing the objects to be recognized and (ii) call recognize() with the 3D scene in which the objects should be recognized. Recognition means both object identification and pose (position + orientation) estimation. Check the method descriptions for more details |

mets::observer< observed_subject > | Template base class for the observers of some observed_subject |

pcl::poisson::OctNode< NodeData, Real > | |

pcl::search::Octree< PointT, LeafTWrap, BranchTWrap, OctreeT > | search::Octree is a wrapper class which implements nearest neighbor search operations based on the pcl::octree::Octree structure |

pcl::poisson::Octree< Degree > | |

pcl::octree::Octree2BufBase< LeafContainerT, BranchContainerT > | Octree double buffer class |

pcl::octree::OctreeBase< LeafContainerT, BranchContainerT > | Octree class |

pcl::octree::OctreeBranchNode< ContainerT > | Abstract octree branch class |

pcl::octree::OctreeBreadthFirstIterator< OctreeT > | Octree iterator class |

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::OctreeDepthFirstIterator< OctreeT > | Octree iterator class |

pcl::octree::OctreeIteratorBase< OctreeT > | Abstract octree iterator class |

pcl::octree::OctreeKey | Octree key class |

pcl::octree::OctreeLeafNode< ContainerT > | Abstract octree leaf class |

pcl::octree::OctreeLeafNodeIterator< OctreeT > | Octree leaf node iterator class |

pcl::octree::OctreeNode | Abstract octree node class |

pcl::octree::OctreeNodePool< NodeT > | Octree node pool |

OctreePointCloud | |

pcl::octree::OctreePointCloud< PointT, LeafContainerT, BranchContainerT, OctreeT > | Octree pointcloud class |

pcl::octree::OctreePointCloudAdjacency< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud voxel class used for adjacency calculation |

pcl::octree::OctreePointCloudAdjacencyContainer< PointInT, DataT > | Octree adjacency leaf container class- stores set of pointers to neighbors, number of points added, and a DataT value |

pcl::octree::OctreePointCloudChangeDetector< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud change detector class |

pcl::io::OctreePointCloudCompression< PointT, LeafT, BranchT, OctreeT > | Octree pointcloud compression class |

pcl::octree::OctreePointCloudDensity< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud density class |

pcl::octree::OctreePointCloudDensityContainer | Octree pointcloud density leaf node class |

pcl::octree::OctreePointCloudOccupancy< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud occupancy class |

pcl::octree::OctreePointCloudPointVector< PointT, LeafContainerT, BranchContainerT, OctreeT > | Octree pointcloud point vector class |

pcl::octree::OctreePointCloudSearch< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud search class |

pcl::octree::OctreePointCloudSinglePoint< PointT, LeafContainerT, BranchContainerT, OctreeT > | Octree pointcloud single point class |

pcl::octree::OctreePointCloudVoxelCentroid< PointT, LeafContainerT, BranchContainerT > | Octree pointcloud voxel centroid class |

pcl::octree::OctreePointCloudVoxelCentroidContainer< PointT > | Octree pointcloud voxel centroid leaf node class |

OctreeT | |

OctreeViewer | |

pcl::ihs::OfflineIntegration | Read the clouds and transformations from files and integrate them into one common model |

pcl::traits::offset< PointT, Tag > | |

ON_2dexMap | |

ON_2dPoint | |

ON_2dPointArray | |

ON_2dVector | |

ON_2dVectorArray | |

ON_2fPoint | |

ON_2fPointArray | |

ON_2fVector | |

ON_2fVectorArray | |

ON_3DM_BIG_CHUNK | |

ON_3DM_CHUNK | |

ON_3dmAnnotationSettings | |

ON_3dmApplication | |

ON_3dmConstructionPlane | |

ON_3dmConstructionPlaneGridDefaults | |

ON_3dmGoo | |

ON_3dmIOSettings | |

ON_3dmNotes | |

ON_3dmObjectAttributes | |

ON_3dmPageSettings | |

ON_3dmProperties | |

ON_3dmRenderSettings | |

ON_3dmRevisionHistory | |

ON_3dmSettings | |

ON_3dmUnitsAndTolerances | |

ON_3dmView | |

ON_3dmViewPosition | |

ON_3dmViewTraceImage | |

ON_3dmWallpaperImage | |

ON_3dPoint | |

ON_3dPointArray | |

ON_3dRay | |

ON_3dVector | |

ON_3dVectorArray | |

ON_3fPoint | |

ON_3fPointArray | |

ON_3fVector | |

ON_3fVectorArray | |

ON_4dPoint | |

ON_4dPointArray | |

ON_4fPoint | |

ON_4fPointArray | |

ON__3dmV1_XDATA | |

ON__3dmV1LayerIndex | |

ON__CChangeTextureCoordinateHelper | |

ON__CIndexMaps | |

ON__CIndexPair | |

ON__ClassIdDumpNode | |

ON__CMeshFaceTC | |

ON__CNewMeshFace | |

ON__EDGE_ENDS | |

ON__IDefAlternativePathUserData | |

ON__IDefLayerSettingsUserData | |

ON__LayerExtensions | |

ON__LayerPerViewSettings | |

ON__LayerSettingsUserData | |

ON__MESHEDGE | |

ON__NEWVI | |

ON__OBSOLETE__CircleCurve | |

ON_AngularDimension | |

ON_AngularDimension2 | |

ON_AngularDimension2Extra | |

ON_Annotation | |

ON_Annotation2 | |

ON_Annotation2Text | |

ON_AnnotationArrow | |

ON_AnnotationTextDot | |

ON_AnnotationTextFormula | |

ON_Arc | |

ON_ArcCurve | |

ON_aStringHeader | |

ON_Base64EncodeImplementation | |

ON_Base64EncodeStream | |

ON_BezierCage | |

ON_BezierCageMorph | |

ON_BezierCurve | |

ON_BezierSurface | |

ON_BinaryArchive | |

ON_BinaryArchiveBuffer | |

ON_BinaryFile | |

ON_Bitmap | |

ON_BoolValue | |

ON_BoundingBox | |

ON_Box | |

ON_Brep | |

ON_BrepEdge | |

ON_BrepEdgeArray | |

ON_BrepFace | |

ON_BrepFaceArray | |

ON_BrepFaceSide | |

ON_BrepFaceSideArray | |

ON_BrepLoop | |

ON_BrepLoopArray | |

ON_BrepRegion | |

ON_BrepRegionArray | |

ON_BrepRegionTopology | |

ON_BrepRegionTopologyUserData | |

ON_BrepTrim | |

ON_BrepTrimArray | |

ON_BrepTrimPoint | |

ON_BrepVertex | |

ON_BrepVertexArray | |

ON_Buffer | |

ON_BUFFER_SEGMENT | |

ON_BumpFunction | |

ON_CageMorph | |

ON_CheckSum | |

ON_Circle | |

ON_ClassArray< T > | |

ON_ClassId | |

ON_ClippingPlane | |

ON_ClippingPlaneInfo | |

ON_ClippingPlaneSurface | |

ON_ClippingRegion | |

ON_Color | |

ON_ColorValue | |

ON_CompressedBuffer | |

ON_CompressedBufferHelper | |

ON_CompressStream | |

ON_Cone | |

ON_Curve | |

ON_CurveArray | |

ON_CurveOnSurface | |

ON_CurveProxy | |

ON_CurveProxyHistory | |

ON_Cylinder | |

ON_DecodeBase64 | |

ON_DetailView | |

ON_DimensionExtra | |

ON_DimStyle | |

ON_DimStyleExtra | |

ON_DisplayMaterialRef | |

ON_DocumentUserStringList | |

ON_DoubleValue | |

ON_DummyValue | |

ON_EarthAnchorPoint | |

ON_Ellipse | |

ON_EmbeddedBitmap | |

ON_EmbeddedFile | |

ON_Evaluator | |

ON_Extrusion | |

ON_Extrusion_BrepForm_FaceInfo | |

ON_FileIterator | |

ON_FileStream | |

ON_FixedSizePool | |

ON_FixedSizePoolIterator | |

ON_Font | |

ON_Geometry | |

ON_GeometryValue | |

ON_Group | |

ON_Hatch | |

ON_HatchExtra | |

ON_HatchLine | |

ON_HatchLoop | |

ON_HatchPattern | |

ON_HistoryRecord | |

ON_InstanceDefinition | |

ON_InstanceRef | |

ON_Interval | |

ON_IntValue | |

ON_Layer | |

ON_Leader | |

ON_Leader2 | |

ON_Light | |

ON_Line | |

ON_LinearDimension | |

ON_LinearDimension2 | |

ON_LineCurve | |

ON_Linetype | |

ON_LinetypeSegment | |

ON_Localizer | |

ON_LocalZero1 | |

ON_MappingChannel | |

ON_MappingRef | |

ON_MappingTag | |

ON_Material | |

ON_MaterialRef | |

ON_Matrix | |

ON_Mesh | |

ON_MeshCurvatureStats | |

ON_MeshCurveParameters | |

ON_MeshDoubleVertices | |

ON_MeshEdgeRef | |

ON_MeshFace | |

ON_MeshFaceRef | |

ON_MeshFaceSide | |

ON_MeshNgon | |

ON_MeshNgonList | |

ON_MeshNgonUserData | |

ON_MeshParameters | |

ON_MeshPart | |

ON_MeshPartition | |

ON_MeshTopology | |

ON_MeshTopologyEdge | |

ON_MeshTopologyFace | |

ON_MeshTopologyVertex | |

ON_MeshVertexRef | |

ON_MorphControl | |

ON_NGON_MEMBLK | |

ON_NurbsCage | |

ON_NurbsCurve | |

ON_NurbsSurface | |

ON_Object | |

ON_ObjectArray< T > | |

ON_ObjectRenderingAttributes | |

ON_ObjRef | |

ON_ObjRef_IRefID | |

ON_ObjRefEvaluationParameter | |

ON_ObjRefValue | |

ON_OBSOLETE_CCustomMeshUserData | |

ON_OffsetSurface | |

ON_OffsetSurfaceFunction | |

ON_OffsetSurfaceValue | |

ON_OrdinateDimension2 | |

ON_PerObjectMeshParameters | |

ON_PgonPt | |

ON_Plane | |

ON_PlaneEquation | |

ON_PlaneSurface | |

ON_PlugInRef | |

ON_Point | |

ON_PointCloud | |

ON_PointGrid | |

ON_PointValue | |

ON_PolyCurve | |

ON_PolyEdgeCurve | |

ON_PolyEdgeHistory | |

ON_PolyEdgeHistoryValue | |

ON_PolyEdgeSegment | |

ON_Polyline | |

ON_PolylineCurve | |

ON_PolynomialCurve | |

ON_PolynomialSurface | |

ON_RadialDimension | |

ON_RadialDimension2 | |

ON_RANDOM_NUMBER_CONTEXT | |

ON_Read3dmBufferArchive | |

ON_ReadChunkHelper | |

ON_RenderingAttributes | |

ON_RevolutionTensor | |

ON_RevSurface | |

ON_RTree | |

ON_RTreeBBox | |

ON_RTreeBranch | |

ON_RTreeCapsule | |

ON_RTreeIterator | |

ON_RTreeLeaf | |

ON_RTreeListNode | A link list of nodes for reinsertion after a delete operation |

ON_RTreeMemPool | |

ON_RTreeNode | |

ON_RTreePairSearchCallbackResult | |

ON_RTreePairSearchCallbackResultBool | |

ON_RTreePairSearchResult | |

ON_RTreePartitionVars | Variables for finding a split partition |

ON_RTreeSearchResult | |

ON_RTreeSearchResultCallback | |

ON_RTreeSphere | |

ON_SerialNumberMap | |

ON_SimpleArray< T > | |

ON_SimpleFixedSizePool< T > | |

ON_SpaceMorph | |

ON_Sphere | |

ON_String | |

ON_StringValue | |

ON_Sum | |

ON_SumSurface | |

ON_SumTensor | |

ON_Surface | |

ON_SurfaceArray | |

ON_SurfaceCurvature | |

ON_SurfaceProperties | |

ON_SurfaceProxy | |

ON_TensorProduct | |

ON_TextDot | |

ON_TextEntity | |

ON_TextEntity2 | |

ON_TextExtra | |

ON_TextLog | |

ON_Texture | |

ON_TextureCoordinates | |

ON_TextureMapping | |

ON_Torus | |

ON_U | |

ON_UncompressStream | |

ON_UnicodeErrorParameters | |

ON_UnitSystem | |

ON_UnknownUserData | |

ON_UnknownUserDataArchive | |

ON_UserData | |

ON_UserDataHolder | |

ON_UserString | |

ON_UserStringList | |

ON_UUID | |

ON_UuidIndexList | |

ON_UuidList | |

ON_UuidPair | |

ON_UuidPairList | |

ON_UuidValue | |

ON_Value | |

ON_VectorValue | |

ON_Viewport | |

ON_WindowsBitmap | |

ON_WindowsBitmapEx | |

ON_WindowsBITMAPINFO | |

ON_WindowsBITMAPINFOHEADER | |

ON_WindowsRGBQUAD | |

ON_Workspace | |

ON_Workspace_FBLK | |

ON_Workspace_MBLK | |

ON_Write3dmBufferArchive | |

ON_wString | |

ON_wStringHeader | |

ON_Xform | |

ON_XformValue | |

ON_ZlibImplementation | |

ONX_Model | |

ONX_Model_Object | |

ONX_Model_RenderLight | |

ONX_Model_UserData | |

pcl::ihs::OpenGLViewer | Viewer for the in-hand scanner based on Qt and OpenGL |

OpenNI3DConcaveHull< PointType > | |

OpenNI3DConvexHull< PointType > | |

OpenNICapture | |

OpenNIChangeViewer | |

pcl::apps::optronic_viewer::OpenNIDevice | |

OpenNIFastMesh< PointType > | |

OpenNIFeaturePersistence< PointType > | |

OpenNIFrameSource::OpenNIFrameSource | |

pcl::apps::optronic_viewer::OpenNIGrabber | Wrapper for the grabbing from an OpenNI device. Wrapper is used to run the grabbing in a separate thread (QThread) |

OpenNIGrabFrame< PointType > | |

OpenNIIntegralImageNormalEstimation< PointType > | |

OpenNIOrganizedMultiPlaneSegmentation | |

OpenNIPassthrough< PointType > | |

OpenNIPlanarSegmentation< PointType > | |

OpenNISegmentTracking< PointType > | |

OpenNISmoothing< PointType > | |

OpenNIUniformSampling | |

OpenNIViewer< PointType > | |

OpenNIVoxelGrid< PointType > | |

pcl::SampleConsensusModelCylinder< PointT, PointNT >::OptimizationFunctor | Functor for the optimization function |

pcl::SampleConsensusModelCircle3D< PointT >::OptimizationFunctor | Functor for the optimization function |

pcl::SampleConsensusModelSphere< PointT >::OptimizationFunctor | |

pcl::SampleConsensusModelCone< PointT, PointNT >::OptimizationFunctor | Functor for the optimization function |

pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar >::OptimizationFunctor | |

pcl::registration::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar >::OptimizationFunctor | |

pcl::SampleConsensusModelCircle2D< PointT >::OptimizationFunctor | Functor for the optimization function |

pcl::GeneralizedIterativeClosestPoint< PointSource, PointTarget >::OptimizationFunctorWithIndices | Optimization functor structure |

pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar >::OptimizationFunctorWithIndices | |

pcl::registration::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar >::OptimizationFunctorWithIndices | |

pcl::OrganizedConnectedComponentSegmentation< PointT, PointLT > | OrganizedConnectedComponentSegmentation allows connected components to be found within organized point cloud data, given a comparison function. Given an input cloud and a comparator, it will output a PointCloud of labels, giving each connected component a unique id, along with a vector of PointIndices corresponding to each component. See OrganizedMultiPlaneSegmentation for an example application |

pcl::io::OrganizedConversion< PointT, false > | |

pcl::io::OrganizedConversion< PointT, true > | |

pcl::OrganizedFastMesh< PointInT > | Simple triangulation/surface reconstruction for organized point clouds. Neighboring points (pixels in image space) are connected to construct a triangular mesh |

pcl::OrganizedIndexIterator | Base class for iterators on 2-dimensional maps like images/organized clouds etc |

pcl::OrganizedMultiPlaneSegmentation< PointT, PointNT, PointLT > | OrganizedMultiPlaneSegmentation finds all planes present in the input cloud, and outputs a vector of plane equations, as well as a vector of point clouds corresponding to the inliers of each detected plane. Only planes with more than min_inliers points are detected. Templated on point type, normal type, and label type |

pcl::search::OrganizedNeighbor< PointT > | OrganizedNeighbor is a class for optimized nearest neigbhor search in organized point clouds |

pcl::io::OrganizedPointCloudCompression< PointT > | |

OrganizedSegmentationDemo | |

pcl::cloud_composer::OrganizedSegmentationTool | |

pcl::cloud_composer::OrganizedSegmentationToolFactory | |

pcl::recognition::ObjRecRANSAC::OrientedPointPair | |

pcl::recognition::ORRGraph< NodeData > | |

pcl::recognition::ORROctree | That's a very specialized and simple octree class. That's the way it is intended to be, that's why no templates and stuff like this |

pcl::recognition::ORROctreeZProjection | |

testing::internal::OsStackTraceGetter | |

testing::internal::OsStackTraceGetterInterface | |

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::geometry::OuterHalfEdgeAroundFaceCirculator< MeshT > | Circulates clockwise around a face and returns an index to the outer half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getOuterHalfEdgeAroundFaceCirculator () |

pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< MeshT > | Circulates counter-clockwise around a vertex and returns an index to the outgoing half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getOutgoingHalfEdgeAroundVertexCirculator () |

pcl::outofcore::OutofcoreAbstractMetadata | |

pcl::outofcore::OutofcoreAbstractNodeContainer< PointT > | |

pcl::outofcore::OutofcoreBreadthFirstIterator< PointT, ContainerT > | |

OutofcoreCloud | |

pcl::outofcore::OutofcoreDepthFirstIterator< PointT, ContainerT > | |

pcl::outofcore::OutofcoreIteratorBase< PointT, ContainerT > | Abstract octree iterator class |

pcl::outofcore::OutofcoreOctreeBase< ContainerT, PointT > | This code defines the octree used for point storage at Urban Robotics |

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::OutofcoreOctreeBaseNode< ContainerT, PointT > | OutofcoreOctreeBaseNode Class internally representing nodes of an outofcore octree, with accessors to its data via the octree_disk_container class or octree_ram_container class, whichever it is templated against |

pcl::outofcore::OutofcoreOctreeDiskContainer< PointT > | Class responsible for serialization and deserialization of out of core point data |

pcl::outofcore::OutofcoreOctreeNodeMetadata | Encapsulated class to read JSON metadata into memory, and write the JSON metadata for each node |

pcl::outofcore::OutofcoreOctreeRamContainer< PointT > | Storage container class which the outofcore octree base is templated against |

pcl::outofcore::OutofcoreParams | |

OutofcoreTest | |

pcl::recognition::ObjRecRANSAC::Output | This is an output item of the ObjRecRANSAC::recognize() method. It contains the recognized model, its name (the ones passed to ObjRecRANSAC::addModel()), the rigid transform which aligns the model with the input scene and the match confidence which is a number in the interval (0, 1] which gives the fraction of the model surface area matched to the scene. E.g., a match confidence of 0.3 means that 30% of the object surface area was matched to the scene points. If the scene is represented by a single range image, the match confidence can not be greater than 0.5 since the range scanner sees only one side of each object |

pcl::cloud_composer::OutputPair | |

pcl::PackedHSIComparison< PointT > | A packed HSI specialization of the comparison object |

pcl::PackedRGBComparison< PointT > | A packed rgb specialization of the comparison object |

pcl::io::ply::ply_parser::list_property_definition_callbacks_type::pair_with< T > | |

pcl::PairwiseGraphRegistration< GraphT, PointT > | PairwiseGraphRegistration class aligns the clouds two by two |

pcl::PapazovHV< ModelT, SceneT > | A hypothesis verification method proposed in "An Efficient RANSAC for 3D Object Recognition in Noisy and Occluded Scenes", C. Papazov and D. Burschka, ACCV 2010 |

boost::parallel_edge_traits< eigen_listS > | |

boost::parallel_edge_traits< eigen_vecS > | |

pcl::on_nurbs::FittingSurfaceIM::Parameter | Parameters for fitting |

pcl::on_nurbs::ClosingBoundary::Parameter | |

pcl::on_nurbs::FittingCurve2d::Parameter | Parameters for fitting |

pcl::on_nurbs::FittingCurve2dAPDM::Parameter | Parameters for fitting |

pcl::on_nurbs::FittingCurve2dPDM::Parameter | Parameters for fitting |

pcl::on_nurbs::FittingSurface::Parameter | Parameters for fitting |

pcl::on_nurbs::SequentialFitter::Parameter | |

pcl::on_nurbs::FittingCurve::Parameter | |

pcl::modeler::Parameter | |

pcl::on_nurbs::GlobalOptimization::Parameter | Parameters for fitting |

pcl::modeler::ParameterDelegate | |

pcl::modeler::ParameterDialog | |

pcl::modeler::ParameterModel | |

pcl::NarfKeypoint::Parameters | Parameters used in this class |

pcl::common::UniformGenerator< T >::Parameters | |

pcl::RangeImageBorderExtractor::Parameters | Parameters used in this class |

pcl::PolynomialCalculationsT< real >::Parameters | Parameters used in this class |

pcl::PosesFromMatches::Parameters | Parameters used in this class |

pcl::NarfDescriptor::Parameters | |

pcl::common::NormalGenerator< T >::Parameters | |

BFGS< FunctorType >::Parameters | |

pcl::on_nurbs::FittingSurfaceTDM::ParameterTDM | Parameters with TDM extensions for fitting |

pcl::on_nurbs::GlobalOptimizationTDM::ParameterTDM | Parameters for fitting |

pcl::tracking::ParticleFilterOMPTracker< PointInT, StateT > | ParticleFilterOMPTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method in parallel, using the OpenMP standard |

pcl::tracking::ParticleFilterTracker< PointInT, StateT > | ParticleFilterTracker tracks the PointCloud which is given by setReferenceCloud within the measured PointCloud using particle filter method |

pcl::tracking::ParticleXYR | |

pcl::tracking::ParticleXYRP | |

pcl::tracking::ParticleXYRPY | |

pcl::tracking::ParticleXYZR | |

pcl::tracking::ParticleXYZRPY | |

pcl::PassThrough< PointT > | PassThrough passes points in a cloud based on constraints for one particular field of the point type |

pcl::PassThrough< pcl::PCLPointCloud2 > | PassThrough uses the base Filter class methods to pass through all data that satisfies the user given constraints |

pcl::apps::optronic_viewer::PassThroughCF | Wrapper for a pass-through filter. Removes all points that are out of a specified range for a specified component (e.g. x, y, or z) |

PasteCommand | |

pcl::PCA< PointT > | |

PCD | |

PCDBuffer< PointT > | |

PCDComparator | |

pcl::PCDGrabber< PointT > | |

pcl::PCDGrabberBase | Base class for PCD file grabber |

pcl::PCDGrabberBase::PCDGrabberImpl | |

PCDOrganizedMultiPlaneSegmentation< PointT > | |

OutofcoreCloud::PcdQueueItem | |

pcl::PCDReader | Point Cloud Data (PCD) file format reader |

PCDVideoPlayer | |

pcl::PCDWriter | Point Cloud Data (PCD) file format writer |

pcl::PCLBase< PointT > | PCL base class. Implements methods that are used by most PCL algorithms |

pcl::PCLBase< pcl::PCLPointCloud2 > | |

pcl::visualization::PCLContextImageItem | |

pcl::visualization::PCLContextItem | |

pcl::PCLException | A base class for all pcl exceptions which inherits from std::runtime_error |

pcl::PCLHeader | |

pcl::visualization::PCLHistogramVisualizer | PCL histogram visualizer main class |

pcl::visualization::PCLHistogramVisualizerInteractorStyle | PCL histogram visualizer interactory style class |

pcl::PCLImage | |

pcl::visualization::PCLImageCanvasSource2D | PCLImageCanvasSource2D represents our own custom version of vtkImageCanvasSource2D, used by the ImageViewer class |

PCLMobileServer< PointType > | |

pcl::visualization::PCLPainter2D | PCL Painter2D main class. Class for drawing 2D figures |

pcl::visualization::PCLPlotter | PCL Plotter main class. Given point correspondences this class can be used to plot the data one against the other and display it on the screen. It also has methods for providing plot for important functions like histogram etc. Important functions of PCLHistogramVisualizer are redefined here so that this single class can take responsibility of all plotting related functionalities |

pcl::PCLPointCloud2 | |

pcl::PCLPointField | |

pcl::visualization::PCLSimpleBufferVisualizer | PCL simple buffer visualizer main class |

pcl::PCLSurfaceBase< PointInT > | Pure abstract class. All types of meshing/reconstruction algorithms in libpcl_surface must inherit from this, in order to make sure we have a consistent API. The methods that we care about here are: |

pcl::visualization::PCLVisualizer | PCL Visualizer main class |

pcl::visualization::PCLVisualizerInteractor | The PCLVisualizer interactor |

pcl::visualization::PCLVisualizerInteractorStyle | PCLVisualizerInteractorStyle defines an unique, custom VTK based interactory style for PCL Visualizer applications. Besides defining the rendering style, we also create a list of custom actions that are triggered on different keys being pressed: |

pcl::CRHAlignment< PointT, nbins_ >::peaks_ordering | Sorts peaks |

mets::permutation_problem | An abstract permutation problem |

pcl::people::PersonClassifier< PointT > | |

pcl::people::PersonCluster< PointT > | |

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::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::PlanarPolygon< PointT > | PlanarPolygon represents a planar (2D) polygon, potentially in a 3D space |

pcl::PlanarPolygonFusion< PointT > | PlanarPolygonFusion takes a list of 2D planar polygons and attempts to reduce them to a minimum set that best represents the scene, based on various given comparators |

pcl::PlanarRegion< PointT > | PlanarRegion represents a set of points that lie in a plane. Inherits summary statistics about these points from Region3D, and summary statistics of a 3D collection of points |

pcl::apps::optronic_viewer::PlaneCF | Wrapper for a filter that finds the dominant plane in the cloud and either keeps only the plane or everything else |

pcl::PlaneClipper3D< PointT > | Implementation of a plane clipper in 3D |

pcl::PlaneCoefficientComparator< PointT, PointNT > | PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data |

pcl::PlaneRefinementComparator< PointT, PointNT, PointLT > | PlaneRefinementComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data |

Player | |

pcl::io::ply::ply_parser | |

ply_to_obj_converter | |

ply_to_ply_converter | |

ply_to_raw_converter | |

pcl::PLYReader | Point Cloud Data (PLY) file format reader |

pcl::PLYWriter | Point Cloud Data (PLY) file format writer |

pcl::traits::POD< PointT > | |

pcl::visualization::context_items::Point | |

pcl::poisson::Point3D< Real > | |

pcl::PointCloud< PointT > | PointCloud represents the base class in PCL for storing collections of 3D points |

PointCloudBuffers | |

pcl::tracking::PointCloudCoherence< PointInT > | PointCloudCoherence is a base class to compute coherence between the two PointClouds |

pcl::visualization::PointCloudColorHandler< PointT > | Base Handler class for PointCloud colors |

pcl::visualization::PointCloudColorHandler< pcl::PCLPointCloud2 > | Base Handler class for PointCloud colors |

pcl::visualization::PointCloudColorHandlerCustom< PointT > | Handler for predefined user colors. The color at each point will be drawn as the use given R, G, B values |

pcl::visualization::PointCloudColorHandlerCustom< pcl::PCLPointCloud2 > | Handler for predefined user colors. The color at each point will be drawn as the use given R, G, B values |

pcl::visualization::PointCloudColorHandlerGenericField< PointT > | Generic field handler class for colors. Uses an user given field to extract 1D data and display the color at each point using a min-max lookup table |

pcl::visualization::PointCloudColorHandlerGenericField< pcl::PCLPointCloud2 > | Generic field handler class for colors. Uses an user given field to extract 1D data and display the color at each point using a min-max lookup table |

pcl::visualization::PointCloudColorHandlerHSVField< PointT > | HSV handler class for colors. Uses the data present in the "h", "s", "v" fields as the color at each point |

pcl::visualization::PointCloudColorHandlerHSVField< pcl::PCLPointCloud2 > | HSV handler class for colors. Uses the data present in the "h", "s", "v" fields as the color at each point |

pcl::visualization::PointCloudColorHandlerRandom< PointT > | Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen) |

pcl::visualization::PointCloudColorHandlerRandom< pcl::PCLPointCloud2 > | Handler for random PointCloud colors (i.e., R, G, B will be randomly chosen) |

pcl::visualization::PointCloudColorHandlerRGBField< PointT > | RGB handler class for colors. Uses the data present in the "rgb" or "rgba" fields as the color at each point |

pcl::visualization::PointCloudColorHandlerRGBField< pcl::PCLPointCloud2 > | RGB handler class for colors. Uses the data present in the "rgb" or "rgba" fields as the color at each point |

pcl::visualization::PointCloudGeometryHandler< PointT > | Base handler class for PointCloud geometry |

pcl::visualization::PointCloudGeometryHandler< pcl::PCLPointCloud2 > | Base handler class for PointCloud geometry |

pcl::visualization::PointCloudGeometryHandlerCustom< PointT > | Custom handler class for PointCloud geometry. Given an input dataset and three user defined fields, all data present in them is extracted and displayed on screen as XYZ data |

pcl::visualization::PointCloudGeometryHandlerCustom< pcl::PCLPointCloud2 > | Custom handler class for PointCloud geometry. Given an input dataset and three user defined fields, all data present in them is extracted and displayed on screen as XYZ data |

pcl::visualization::PointCloudGeometryHandlerSurfaceNormal< PointT > | Surface normal handler class for PointCloud geometry. Given an input dataset, all data present in fields "normal_x", "normal_y", and "normal_z" is extracted and dislayed on screen as XYZ data |

pcl::visualization::PointCloudGeometryHandlerSurfaceNormal< pcl::PCLPointCloud2 > | Surface normal handler class for PointCloud geometry. Given an input dataset, all data present in fields "normal_x", "normal_y", and "normal_z" is extracted and dislayed on screen as XYZ data |

pcl::visualization::PointCloudGeometryHandlerXYZ< PointT > | XYZ handler class for PointCloud geometry. Given an input dataset, all XYZ data present in fields "x", "y", and "z" is extracted and displayed on screen |

pcl::visualization::PointCloudGeometryHandlerXYZ< pcl::PCLPointCloud2 > | XYZ handler class for PointCloud geometry. Given an input dataset, all XYZ data present in fields "x", "y", and "z" is extracted and displayed on screen |

pcl::octree::PointCoding< PointT > | PointCoding class |

pcl::tracking::PointCoherence< PointInT > | PointCoherence is a base class to compute coherence between the two points |

pcl::PointCorrespondence3D | Representation of a (possible) correspondence between two 3D points in two different coordinate frames (e.g. from feature matching) |

pcl::PointCorrespondence6D | Representation of a (possible) correspondence between two points (e.g. from feature matching), that encode complete 6DOF transoformations |

pcl::poisson::Octree< Degree >::PointData | |

pcl::PointDataAtOffset< PointT > | A datatype that enables type-correct comparisons |

pcl::ihs::PointIHS | |

pcl::PointIndices | |

pcl::poisson::Octree< Degree >::PointInfo | |

pcl::PointNormal | A point structure representing Euclidean xyz coordinates, together with normal coordinates and the surface curvature estimate. (SSE friendly) |

pcl::visualization::PointPickingCallback | |

pcl::visualization::PointPickingEvent | |

pcl::PointRepresentation< PointT > | PointRepresentation provides a set of methods for converting a point structs/object into an n-dimensional vector |

pcl::PointRGB | A point structure for representing RGB color |

pcl::visualization::context_items::Points | |

pcl::modeler::PointsActorItem | |

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::PointUV | A 2D point structure representing pixel image coordinates |

pcl::PointWithRange | A point structure representing Euclidean xyz coordinates, padded with an extra range float |

pcl::PointWithScale | A point structure representing a 3-D position and scale |

pcl::PointWithViewpoint | A point structure representing Euclidean xyz coordinates together with the viewpoint from which it was seen |

pcl::PointXY | A 2D point structure representing Euclidean xy coordinates |

pcl::PointXYZ | A point structure representing Euclidean xyz coordinates. (SSE friendly) |

PointXYZFPFH33 | |

pcl::PointXYZHSV | |

pcl::PointXYZI | |

pcl::PointXYZINormal | A point structure representing Euclidean xyz coordinates, intensity, together with normal coordinates and the surface curvature estimate |

pcl::PointXYZL | |

pcl::PointXYZRGB | A point structure representing Euclidean xyz coordinates, and the RGB color |

pcl::PointXYZRGBA | A point structure representing Euclidean xyz coordinates, and the RGBA color |

pcl::PointXYZRGBL | |

pcl::PointXYZRGBNormal | A point structure representing Euclidean xyz coordinates, and the RGB color, together with normal coordinates and the surface curvature estimate. Due to historical reasons (PCL was first developed as a ROS package), the RGB information is packed into an integer and casted to a float. This is something we wish to remove in the near future, but in the meantime, the following code snippet should help you pack and unpack RGB colors in your PointXYZRGB structure: |

pcl::Poisson< PointNT > | The Poisson surface reconstruction algorithm |

pcl::modeler::PoissonReconstructionWorker | |

pcl::visualization::context_items::Polygon | |

pcl::PolygonMesh | |

pcl::geometry::PolygonMesh< MeshTraitsT > | General half-edge mesh that can store any polygon with a minimum number of vertices of 3 |

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 |

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

pcl::PPFRegistration< PointSource, PointTarget >::PoseWithVotes | Structure for storing a pose (represented as an Eigen::Affine3f) and an integer for counting votes |

pcl::PPFEstimation< PointInT, PointNT, PointOutT > | Class that calculates the "surflet" features for each pair in the given pointcloud. Please refer to the following publication for more details: B. Drost, M. Ulrich, N. Navab, S. Ilic Model Globally, Match Locally: Efficient and Robust 3D Object Recognition 2010 IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 13-18 June 2010, San Francisco, CA |

pcl::PPFHashMapSearch | |

pcl::PPFRegistration< PointSource, PointTarget > | Class that registers two point clouds based on their sets of PPFSignatures. Please refer to the following publication for more details: B. Drost, M. Ulrich, N. Navab, S. Ilic Model Globally, Match Locally: Efficient and Robust 3D Object Recognition 2010 IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 13-18 June 2010, San Francisco, CA |

pcl::PPFRGBEstimation< PointInT, PointNT, PointOutT > | |

pcl::PPFRGBRegionEstimation< PointInT, PointNT, PointOutT > | |

pcl::PPFRGBSignature | A point structure for storing the Point Pair Color Feature (PPFRGB) values |

pcl::PPFSignature | A point structure for storing the Point Pair Feature (PPF) values |

pcl::poisson::PPolynomial< Degree > | |

testing::internal::PrettyUnitTestResultPrinter | |

pcl::PrincipalCurvatures | A point structure representing the principal curvatures and their magnitudes |

pcl::PrincipalCurvaturesEstimation< PointInT, PointNT, PointOutT > | PrincipalCurvaturesEstimation estimates the directions (eigenvectors) and magnitudes (eigenvalues) of principal surface curvatures for a given point cloud dataset containing points and normals |

pcl::PrincipalRadiiRSD | A point structure representing the minimum and maximum surface radii (in meters) computed using RSD |

mets::printable | An interface for printable objects |

pcl::octree::OctreePointCloudSearch< PointT, LeafContainerT, BranchContainerT >::prioBranchQueueEntry | Priority queue entry for branch nodes |

prioPointQueueEntry | |

pcl::octree::OctreePointCloudSearch< PointT, LeafContainerT, BranchContainerT >::prioPointQueueEntry | Priority queue entry for point candidates |

Producer< PointT > | |

pcl::ProgressiveSampleConsensus< PointT > | RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Matching with PROSAC â€“ Progressive Sample Consensus", Chum, O. and Matas, J.G., CVPR, I: 220-226 2005 |

pcl::ProjectInliers< PointT > | ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud |

pcl::ProjectInliers< pcl::PCLPointCloud2 > | ProjectInliers uses a model and a set of inlier indices from a PointCloud to project them into a separate PointCloud |

pcl::cloud_composer::ProjectModel | |

pcl::cloud_composer::PropertiesModel | |

pcl::io::ply::ply_parser::property | |

pcl::filters::Pyramid< PointT > | |

pcl::PyramidFeatureHistogram< PointFeature > | Class that compares two sets of features by using a multiscale representation of the features inside a pyramid. Each level of the pyramid offers information about the similarity of the two feature sets |

pcl::PyramidFeatureHistogram< PointFeature >::PyramidFeatureHistogramLevel | Structure for representing a single pyramid histogram level |

pcl::geometry::QuadMesh< MeshTraitsT > | Half-edge mesh that can only store quads |

pcl::geometry::QuadMeshTag | Tag describing the type of the mesh |

pcl::QuantizableModality | Interface for a quantizable modality |

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::apps::optronic_viewer::RadiusOutlierCF | Wrapper for a radius-outlier filter. Removes all points that have less than a specified number of points as neighbors (within a specified radius) |

pcl::RadiusOutlierRemoval< PointT > | RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have |

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 |

testing::internal::Random | |

pcl::RandomizedMEstimatorSampleConsensus< PointT > | RandomizedMEstimatorSampleConsensus represents an implementation of the RMSAC (Randomized M-estimator SAmple Consensus) algorithm, which basically adds a Td,d test (see RandomizedRandomSampleConsensus) to an MSAC estimator (see MEstimatorSampleConsensus) |

pcl::RandomizedRandomSampleConsensus< PointT > | RandomizedRandomSampleConsensus represents an implementation of the RRANSAC (Randomized RAndom SAmple Consensus), as described in "Randomized RANSAC with Td,d test", O. Chum and J. Matas, Proc. British Machine Vision Conf. (BMVC '02), vol. 2, BMVA, pp. 448-457, 2002 |

pcl::RandomSample< PointT > | RandomSample applies a random sampling with uniform probability. Based off Algorithm A from the paper "Faster Methods for Random Sampling" by Jeffrey Scott Vitter. The algorithm runs in O(N) and results in sorted indices http://www.ittc.ku.edu/~jsv/Papers/Vit84.sampling.pdf |

pcl::RandomSample< pcl::PCLPointCloud2 > | RandomSample applies a random sampling with uniform probability |

pcl::apps::optronic_viewer::RandomSampleCF | Wrapper for a random sample filter. Selects a random sample of points from the input cloud |

pcl::RandomSampleConsensus< PointT > | RandomSampleConsensus represents an implementation of the RANSAC (RAndom SAmple Consensus) algorithm, as described in: "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and
Automated Cartography", Martin A. Fischler and Robert C. Bolles, Comm. Of the ACM 24: 381â€“395, June 1981 |

pcl::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::RangeImageBorderExtractor | Extract obstacle borders from range images, meaning positions where there is a transition from foreground to background |

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. In the original range image, the image will appear more and more "scaled down" along the y axis, the further away from the mean line of the image a point is. This class removes this scaling, which makes it especially suitable for spinning LIDAR sensors that capure a 360Â° view, since a rotation of the sensor will now simply correspond to a shift of the range image. (This class is similar to RangeImagePlanar, but changes less of the behaviour of the base class.) |

pcl::visualization::RangeImageVisualizer | Range image visualizer class |

testing::internal::RE | |

pcl::GlobalHypothesesVerification< ModelT, SceneT >::RecognitionModel | |

pcl::PapazovHV< ModelT, SceneT >::RecognitionModel | |

pcl::GreedyVerification< ModelT, SceneT >::RecognitionModel | |

Recorder | |

pcl::visualization::context_items::Rectangle | |

pcl::cloud_composer::RectangularFrustumSelector | |

pcl::ReferenceFrame | |

pcl::poisson::Octree< Degree >::RefineFunction | |

pcl::Region3D< PointT > | Region3D represents summary statistics of a 3D collection of points |

pcl::RegionGrowing< PointT, NormalT > | Implements the well known Region Growing algorithm used for segmentation. Description can be found in the article "Segmentation of point clouds using smoothness constraint" by T. Rabbania, F. A. van den Heuvelb, G. Vosselmanc. In addition to residual test, the possibility to test curvature is added |

pcl::RegionGrowingRGB< PointT, NormalT > | Implements the well known Region Growing algorithm used for segmentation based on color of points. Description can be found in the article "Color-based segmentation of point clouds" by Qingming Zhan, Yubin Liang, Yinghui Xiao |

pcl::RegionXY | Defines a region in XY-space |

pcl::Registration< PointSource, PointTarget, Scalar > | Registration represents the base registration class for general purpose, ICP-like methods |

pcl::RegistrationVisualizer< PointSource, PointTarget > | RegistrationVisualizer represents the base class for rendering the intermediate positions ocupied by the source point cloud during it's registration to the target point cloud. A registration algorithm is considered as input and it's covergence is rendered |

RegistrationWrapper< PointSource, PointTarget > | |

testing::internal::RemoveConst< T > | |

testing::internal::RemoveConst< const T > | |

testing::internal::RemoveReference< T > | |

testing::internal::RemoveReference< T & > | |

pcl::apps::RenderViewsTesselatedSphere | Class to render synthetic views of a 3D mesh using a tesselated sphere NOTE: This class should replace renderViewTesselatedSphere from pcl::visualization. Some extensions are planned in the near future to this class like removal of duplicated views for symmetrical objects, generation of RGB synthetic clouds when RGB available on mesh, etc |

pcl::modeler::RenderWindow | |

pcl::modeler::RenderWindowItem | |

pcl::visualization::RenWinInteract | |

TemplateAlignment::Result | |

pcl::RGB | A structure representing RGB color information |

pcl::TexMaterial::RGB | |

pcl::RGBPlaneCoefficientComparator< PointT, PointNT > | RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation. Also takes into account RGB, so we can segmented different colored co-planar regions. In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data |

pcl::tracking::RGBValue | |

pcl::RIFTEstimation< PointInT, GradientT, PointOutT > | RIFTEstimation estimates the Rotation Invariant Feature Transform descriptors for a given point cloud dataset containing points and intensity. For more information about the RIFT descriptor, see: |

pcl::recognition::RigidTransformSpace | |

pcl::RobotEyeGrabber | Grabber for the Ocular Robotics RobotEye sensor |

pcl::poisson::Octree< Degree >::RootData | |

pcl::poisson::RootInfo | |

pcl::recognition::RotationSpace | This is a class for a discrete representation of the rotation space based on the axis-angle representation. This class is not supposed to be very general. That's why it is dependent on the class ModelLibrary |

pcl::recognition::RotationSpaceCell | |

pcl::recognition::RotationSpaceCellCreator | |

pcl::recognition::RotationSpaceCreator | |

pcl::RSDEstimation< PointInT, PointNT, PointOutT > | RSDEstimation estimates the Radius-based Surface Descriptor (minimal and maximal radius of the local surface's curves) for a given point cloud dataset containing points and normals |

pcl::SACSegmentation< PointT > | SACSegmentation represents the Nodelet segmentation class for Sample Consensus methods and models, in the sense that it just creates a Nodelet wrapper for generic-purpose SAC-based segmentation |

pcl::SACSegmentationFromNormals< PointT, PointNT > | SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and models that require the use of surface normals for estimation |

std::tr1::gtest_internal::SameSizeTuplePrefixComparator< 0, 0 > | |

std::tr1::gtest_internal::SameSizeTuplePrefixComparator< k, k > | |

pcl::GlobalHypothesesVerification< ModelT, SceneT >::SAModel | |

pcl::SampleConsensus< T > | SampleConsensus represents the base class. All sample consensus methods must inherit from this class |

pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT > | SampleConsensusInitialAlignment is an implementation of the initial alignment algorithm described in section IV of "Fast Point Feature Histograms (FPFH) for 3D Registration," Rusu et al |

pcl::SampleConsensusModel< PointT > | SampleConsensusModel represents the base model class. All sample consensus models must inherit from this class |

pcl::SampleConsensusModelCircle2D< PointT > | SampleConsensusModelCircle2D defines a model for 2D circle segmentation on the X-Y plane |

pcl::SampleConsensusModelCircle3D< PointT > | SampleConsensusModelCircle3D defines a model for 3D circle segmentation |

pcl::SampleConsensusModelCone< PointT, PointNT > | SampleConsensusModelCone defines a model for 3D cone segmentation. The model coefficients are defined as: |

pcl::SampleConsensusModelCylinder< PointT, PointNT > | SampleConsensusModelCylinder defines a model for 3D cylinder segmentation. The model coefficients are defined as: |

pcl::SampleConsensusModelFromNormals< PointT, PointNT > | SampleConsensusModelFromNormals represents the base model class for models that require the use of surface normals for estimation |

pcl::SampleConsensusModelLine< PointT > | SampleConsensusModelLine defines a model for 3D line segmentation. The model coefficients are defined as: |

pcl::SampleConsensusModelNormalParallelPlane< PointT, PointNT > | SampleConsensusModelNormalParallelPlane defines a model for 3D plane segmentation using additional surface normal constraints. Basically this means that checking for inliers will not only involve a "distance to model" criterion, but also an additional "maximum angular deviation" between the plane's normal and the inlier points normals. In addition, the plane normal must lie parallel to an user-specified axis |

pcl::SampleConsensusModelNormalPlane< PointT, PointNT > | SampleConsensusModelNormalPlane defines a model for 3D plane segmentation using additional surface normal constraints. Basically this means that checking for inliers will not only involve a "distance to model" criterion, but also an additional "maximum angular deviation" between the plane's normal and the inlier points normals |

pcl::SampleConsensusModelNormalSphere< PointT, PointNT > | SampleConsensusModelNormalSphere defines a model for 3D sphere segmentation using additional surface normal constraints. Basically this means that checking for inliers will not only involve a "distance to
model" criterion, but also an additional "maximum angular deviation" between the sphere's normal and the inlier points normals |

pcl::SampleConsensusModelParallelLine< PointT > | SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular constraints. The model coefficients are defined as: |

pcl::SampleConsensusModelParallelPlane< PointT > | SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional angular constraints. The plane must be parallel to a user-specified axis (setAxis) within an user-specified angle threshold (setEpsAngle) |

pcl::SampleConsensusModelPerpendicularPlane< PointT > | SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional angular constraints. The plane must be perpendicular to an user-specified axis (setAxis), up to an user-specified angle threshold (setEpsAngle). The model coefficients are defined as: |

pcl::SampleConsensusModelPlane< PointT > | SampleConsensusModelPlane defines a model for 3D plane segmentation. The model coefficients are defined as: |

pcl::SampleConsensusModelRegistration< PointT > | SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection |

pcl::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. The model coefficients are defined as: |

pcl::SampleConsensusModelStick< PointT > | SampleConsensusModelStick defines a model for 3D stick segmentation. A stick is a line with an user given minimum/maximum width. The model coefficients are defined as: |

pcl::SampleConsensusPrerejective< PointSource, PointTarget, FeatureT > | Pose estimation and alignment class using a prerejective RANSAC routine |

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. Normal is computed using the N points of each grid. All points sampled within a grid are assigned the same normal |

pcl::cloud_composer::SanitizeCloudTool | |

pcl::cloud_composer::SanitizeCloudToolFactory | |

pcl::io::ply::ply_parser::scalar_property< ScalarType > | |

pcl::io::ply::ply_parser::scalar_property_callback_type< ScalarType > | |

pcl::io::ply::ply_parser::scalar_property_definition_callback_type< ScalarType > | |

pcl::io::ply::ply_parser::scalar_property_definition_callbacks_type | |

ScanParameters | |

Scene | |

pcl::modeler::SceneTree | |

testing::internal::scoped_ptr< T > | |

testing::ScopedFakeTestPartResultReporter | |

testing::internal::ScopedTrace | |

pcl::ScopeTime | Class to measure the time spent in a scope |

pcl::keypoints::agast::AbstractAgastDetector::ScoreIndex | Structure holding an index and the associated keypoint score |

pcl::search::Search< PointT > | Generic search class. All search wrappers must inherit from this |

mets::search_listener< move_manager_type > | An object that is called back during the search progress |

pcl::SeededHueSegmentation | SeededHueSegmentation |

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 |

Select1DTool | |

Select2DTool | |

pcl::cloud_composer::SelectedTrackballStyleInteractor | |

Selection | This class serves as a sort of mask for performing operations on a point cloud. It keeps track of the indices of identified/selected points and provides methods for accessing those indices and modifying them |

pcl::cloud_composer::SelectionEvent | |

SelectionTransformTool | The selection transform tool computes the transform matrix from mouse input. It then updates the cloud's transform matrix for the selected points so that the transformed and selected points will be rendered appropriately. Note that, the actual coordinates of the selected points are not updated until the end of the mouse input. At the end of a mouse input (i.e. when the mouse button is released), a transform command is created to update the actual coordinates of the selected points |

mets::sequence | A sequence function object useful as an STL generator |

pcl::io::ply::ply_parser::list_property_definition_callbacks_type::sequence_product< Sequence1, Sequence2 > | |

pcl::on_nurbs::SequentialFitter | |

pcl::recognition::ORROctreeZProjection::Set | |

pcl::SetIfFieldExists< PointOutT, InT > | A helper functor that can set a specific value in a field if the field exists |

testing::Environment::Setup_should_be_spelled_SetUp | |

testing::Test::Setup_should_be_spelled_SetUp | |

pcl::RangeImageBorderExtractor::ShadowBorderIndices | Stores the indices of the shadow border corresponding to obstacle borders |

pcl::ShadowPoints< PointT, NormalT > | ShadowPoints removes the ghost points appearing on edge discontinuties |

pcl::ShapeContext1980 | A point structure representing a Shape Context |

pcl::ShapeContext3DEstimation< PointInT, PointNT, PointOutT > | ShapeContext3DEstimation implements the 3D shape context descriptor as described in: |

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::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::SHOTEstimationBase< PointInT, PointNT, PointOutT, PointRFT > | SHOTEstimation estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset containing points and normals |

pcl::SHOTEstimationOMP< PointInT, PointNT, PointOutT, PointRFT > | 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::SHOTLocalReferenceFrameEstimation< PointInT, PointOutT > | SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor |

pcl::SHOTLocalReferenceFrameEstimationOMP< PointInT, PointOutT > | SHOTLocalReferenceFrameEstimation estimates the Local Reference Frame used in the calculation of the (SHOT) descriptor |

pcl::SIFTKeypoint< PointInT, PointOutT > | SIFTKeypoint detects the Scale Invariant Feature Transform keypoints for a given point cloud dataset containing points and intensity. This implementation adapts the original algorithm from images to point clouds |

pcl::SIFTKeypointFieldSelector< PointT > | |

pcl::SIFTKeypointFieldSelector< PointNormal > | |

pcl::SIFTKeypointFieldSelector< PointXYZ > | |

pcl::SIFTKeypointFieldSelector< PointXYZRGB > | |

pcl::SIFTKeypointFieldSelector< PointXYZRGBA > | |

pcl::cloud_composer::SignalMultiplexer | |

mets::simple_tabu_list | Simplistic implementation of a tabu-list |

SimpleHDLGrabber | |

SimpleHDLViewer< PointType > | |

pcl::recognition::SimpleOctree< NodeData, NodeDataCreator, Scalar > | |

SimpleONIViewer< PointType > | |

SimpleOpenNIProcessor | |

SimpleOpenNIViewer< PointType > | |

pcl::surface::SimplificationRemoveUnusedVertices | |

mets::simulated_annealing< move_manager_type > | Search by Simulated Annealing |

testing::internal::SingleFailureChecker | |

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 |

ON_SerialNumberMap::SN_BLOCK | |

ON_SerialNumberMap::SN_ELEMENT | |

mets::solution_recorder | The solution recorder is used by search algorithm, at the end of each iteration, to record the best seen solution |

pcl::SolverDidntConvergeException | An exception that is thrown when the non linear solver didn't converge |

pcl::registration::sortCorrespondencesByDistance | |

pcl::registration::sortCorrespondencesByMatchIndex | |

pcl::registration::sortCorrespondencesByMatchIndexAndDistance | |

pcl::registration::sortCorrespondencesByQueryIndex | |

pcl::registration::sortCorrespondencesByQueryIndexAndDistance | |

pcl::poisson::SortedTreeNodes | |

pcl::GreedyVerification< ModelT, SceneT >::sortModelIndicesClass | |

pcl::GreedyVerification< ModelT, SceneT >::sortModelsClass | |

pcl::on_nurbs::SparseMat | Sparse matrix implementation |

pcl::poisson::SparseMatrix< T > | |

pcl::SparseQuantizedMultiModTemplate | A multi-modality template constructed from a set of quantized multi-modality features |

pcl::poisson::SparseSymmetricMatrix< T > | |

pcl::SpinImageEstimation< PointInT, PointNT, PointOutT > | Estimates spin-image descriptors in the given input points |

pcl::cloud_composer::SplitCloudCommand | |

pcl::cloud_composer::SplitItemTool | |

pcl::poisson::Square | |

ON_RTreeIterator::StackElement | |

pcl::poisson::StartingPolynomial< Degree > | |

static_tree_desc_s | |

testing::internal::StaticAssertTypeEqHelper< T, T > | |

pcl::StaticRangeCoder | StaticRangeCoder compression class |

pcl::StatisticalMultiscaleInterestRegionExtraction< PointT > | Class for extracting interest regions from unstructured point clouds, based on a multi scale statistical approach. Please refer to the following publications for more details: Ranjith Unnikrishnan and Martial Hebert Multi-Scale Interest Regions from Unorganized Point Clouds Workshop on Search in 3D (S3D), IEEE Conf. on Computer Vision and Pattern Recognition (CVPR) June, 2008 |

pcl::StatisticalOutlierRemoval< PointT > | StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data |

pcl::StatisticalOutlierRemoval< pcl::PCLPointCloud2 > | StatisticalOutlierRemoval uses point neighborhood statistics to filter outlier data. For more information check: |

pcl::cloud_composer::StatisticalOutlierRemovalTool | |

pcl::cloud_composer::StatisticalOutlierRemovalToolFactory | |

pcl::modeler::StatisticalOutlierRemovalWorker | |

Statistics | |

StatisticsDialog | |

pcl::poisson::Octree< Degree >::Stencil< C, N > | |

pcl::StopWatch | Simple stopwatch |

testing::internal::String | |

mets::subject< observed_subject > | Template class for subjects (cfr. Observer Design Pattern) |

pcl::Supervoxel< PointT > | Supervoxel container class - stores a cluster extracted using supervoxel clustering |

pcl::SupervoxelClustering< PointT > | Implements a supervoxel algorithm based on voxel structure, normals, and rgb values |

pcl::SupervoxelClustering< PointT >::SupervoxelHelper | Internal storage class for supervoxels |

pcl::cloud_composer::SupervoxelsTool | |

pcl::cloud_composer::SupervoxelsToolFactory | |

pcl::modeler::SurfaceActorItem | |

pcl::SurfaceNormalModality< PointInT > | Modality based on surface normals |

pcl::SurfaceReconstruction< PointInT > | SurfaceReconstruction represents a base surface reconstruction class. All surface reconstruction methods take in a point cloud and generate a new surface from it, by either re-sampling the data or generating new data altogether. These methods are thus not preserving the topology of the original data |

pcl::SurfelSmoothing< PointT, PointNT > | |

SUSANDemo | |

pcl::SUSANKeypoint< PointInT, PointOutT, NormalT, IntensityT > | SUSANKeypoint implements a RGB-D extension of the SUSAN detector inluding normal directions variation in top of intensity variation. It is different from Harris in that it exploits normals directly so it is faster. Original paper "SUSAN â€” A New Approach to Low Level Image Processing", Smith, Stephen M. and Brady, J. Michael |

mets::swap_elements | A mets::mana_move that swaps two elements in a mets::permutation_problem |

mets::swap_full_neighborhood | Generates a the full swap neighborhood |

mets::swap_neighborhood< random_generator > | Generates a stochastic subset of the neighborhood |

pcl::SynchronizedQueue< T > | |

pcl::Synchronizer< T1, T2 > | |

mets::tabu_list_chain | An abstract tabu list |

mets::tabu_search< move_manager_type > | Tabu Search algorithm |

tagFPT | |

tagMESHPOINTS | |

tagON_2dex | |

tagON_3dex | |

tagON_4dex | |

tagON_RECT | |

tagON_SORT_CONTEXT | |

pcl::io::TARHeader | A TAR file's header, as described on http://en.wikipedia.org/wiki/Tar_%28file_format%29 |

pcl::ism::ImplicitShapeModelEstimation< FeatureSize, PointT, NormalT >::TC | This structure is used for determining the end of the k-means clustering process |

TemplateAlignment | |

mets::termination_criteria_chain | Function object expressing a termination criteria |

testing::Test | |

testing::TestCase | |

testing::internal::TestCaseNameIs | |

testing::TestEventListener | |

testing::TestEventListeners | |

testing::internal::TestEventRepeater | |

testing::internal::TestFactoryBase | |

testing::internal::TestFactoryImpl< TestClass > | |

TestGetBoundary< MeshT > | |

testing::TestInfo | |

TestMeshCirculators | |

TestMeshConversion< MeshTraitsT > | |

TestMeshIndicesTyped< MeshIndexT > | |

testing::TestPartResult | |

testing::TestPartResultArray | |

testing::TestPartResultReporterInterface | |

TestPolygonMesh< MeshT > | |

testing::TestProperty | |

testing::internal::TestPropertyKeyIs | |

TestQuadMesh< MeshT > | |

testing::TestResult | |

testing::internal::TestResultAccessor | |

TestTriangleMesh< MeshT > | |

pcl::TexMaterial | |

pcl::TextureMapping< PointInT > | The texture mapping algorithm |

pcl::TextureMesh | |

pcl::TfQuadraticXYZComparison< PointT > | A comparison whether the (x,y,z) components of a given point satisfy (p'Ap + 2v'p + c [OP] 0). Here [OP] stands for the defined pcl::ComparisonOps, i.e. for GT, GE, LT, LE or EQ; p = (x,y,z) is a point of the point cloud; A is 3x3 matrix; v is the 3x1 vector; c is a scalar |

pcl::modeler::ThreadController | |

testing::internal::ThreadLocal< T > | |

mets::threshold_termination_criteria | Termination criteria based on cost value |

pcl::console::TicToc | |

pcl::TimeTrigger | Timer class that invokes registered callback methods periodically |

pcl::cloud_composer::ToolBoxModel | |

pcl::cloud_composer::ToolFactory | |

ToolInterface | Parent class of all the select and the transform tool classes |

testing::internal::TraceInfo | |

TrackBall | |

pcl::tracking::Tracker< PointInT, StateT > | Tracker represents the base tracker class |

pcl::registration::TransformationEstimation< PointSource, PointTarget, Scalar > | TransformationEstimation represents the base class for methods for transformation estimation based on: |

pcl::registration::TransformationEstimation2D< PointSource, PointTarget, Scalar > | |

pcl::registration::TransformationEstimationLM< PointSource, PointTarget, MatScalar > | |

pcl::registration::TransformationEstimationPointToPlane< PointSource, PointTarget, Scalar > | |

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::TransformationEstimationPointToPlaneWeighted< PointSource, PointTarget, MatScalar > | |

pcl::registration::TransformationEstimationSVD< PointSource, PointTarget, Scalar > | |

pcl::registration::TransformationEstimationSVDScale< PointSource, PointTarget, 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::cloud_composer::TransformClouds | |

TransformCommand | |

tree_desc_s | |

pcl::poisson::TreeNodeData | |

pcl::ihs::detail::FaceVertexMesh::Triangle | |

pcl::poisson::Triangle | |

pcl::poisson::TriangleIndex | |

pcl::geometry::TriangleMesh< MeshTraitsT > | Half-edge mesh that can only store triangles |

pcl::geometry::TriangleMeshTag | Tag describing the type of the mesh |

pcl::poisson::Triangulation< Real > | |

pcl::on_nurbs::Triangulation | Functions for NURBS surface triangulation, trimming and curve sampling |

pcl::poisson::TriangulationEdge | |

pcl::poisson::TriangulationTriangle | |

pcl::recognition::TrimmedICP< PointT, Scalar > | |

pcl::SampleConsensusInitialAlignment< PointSource, PointTarget, FeatureT >::TruncatedError | |

std::tr1::tuple<> | |

std::tr1::tuple<> | |

std::tr1::tuple_element< k, Tuple > | |

std::tr1::tuple_size< GTEST_0_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_10_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_1_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_2_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_3_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_4_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_5_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_6_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_7_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_8_TUPLE_(T)> | |

std::tr1::tuple_size< GTEST_9_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 0, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 1, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 2, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 3, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 4, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 5, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 6, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 7, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 8, GTEST_10_TUPLE_(T)> | |

std::tr1::gtest_internal::TupleElement< true, 9, GTEST_10_TUPLE_(T)> | |

testing::internal::TypeIdHelper< T > | |

testing::internal2::TypeWithoutFormatter< T, kTypeKind > | |

testing::internal2::TypeWithoutFormatter< T, kConvertibleToInteger > | |

testing::internal2::TypeWithoutFormatter< T, kProtobuf > | |

testing::internal::TypeWithSize< size > | |

testing::internal::TypeWithSize< 4 > | |

testing::internal::TypeWithSize< 8 > | |

pcl::UnhandledPointTypeException | |

pcl::common::uniform_distribution< float > | Uniform distribution float specialized |

pcl::common::uniform_distribution< int > | 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::UniformSampling< PointInT > | UniformSampling assembles a local 3D grid over a given PointCloud, and downsamples + filters the data |

pcl::UniqueShapeContext< PointInT, PointOutT, PointRFT > | UniqueShapeContext implements the Unique Shape Context Descriptor described here: |

testing::UnitTest | |

testing::internal::UnitTestImpl | |

testing::internal::UnitTestOptions | |

testing::internal::UniversalPrinter< T > | |

testing::internal::UniversalPrinter< T & > | |

testing::internal::UniversalPrinter< T[N]> | |

pcl::UnorganizedPointCloudException | An exception that is thrown when an organized point cloud is needed but not provided |

mets::update_observer< observed_subject > | Functor class to update observers with a for_each, only intended for internal use |

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 |

pcl::poisson::Vector< T > | |

pcl::VectorAverage< real, dimension > | Calculates the weighted average and the covariance matrix |

pcl::registration::ELCH< PointT >::Vertex | |

pcl::poisson::CoredMeshData2::Vertex | |

pcl::geometry::Vertex | A vertex is a node in the mesh |

pcl::geometry::VertexAroundFaceCirculator< MeshT > | Circulates clockwise around a face and returns an index to the terminating vertex of the inner half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getVertexAroundFaceCirculator () |

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). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getVertexAroundVertexCirculator () |

pcl::poisson::VertexData | |

pcl::geometry::VertexIndex | |

pcl::registration::LUM< PointT >::VertexProperties | |

pcl::Vertices | Describes a set of vertices in a polygon mesh, by basically storing an array of indices |

pcl::VFHClassifierNN | Utility class for nearest neighbor search based classification of VFH features |

pcl::VFHEstimation< PointInT, PointNT, PointOutT > | VFHEstimation estimates the Viewpoint Feature Histogram (VFH) descriptor for a given point cloud dataset containing points and normals. The default VFH implementation uses 45 binning subdivisions for each of the three extended FPFH values, plus another 45 binning subdivisions for the distances between each point and the centroid and 128 binning subdivisions for the viewpoint component, which results in a 308-byte array of float values. These are stored in a pcl::VFHSignature308 point type. A major difference between the PFH/FPFH descriptors and VFH, is that for a given point cloud dataset, only a single VFH descriptor will be estimated (vfhs->points.size() should be 1), while the resultant PFH/FPFH data will have the same number of entries as the number of points in the cloud |

pcl::VFHSignature308 | A point structure representing the Viewpoint Feature Histogram (VFH) |

Viewer | |

Viewport | |

pcl::ihs::InHandScanner::VisualizationFPS | Helper object for the visualization thread. Please have a look at the documentation of calcFPS |

pcl::ihs::OfflineIntegration::VisualizationFPS | Helper object for the visualization thread. Please have a look at the documentation of calcFPS |

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::VoxelGrid< PointT > | VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data |

pcl::VoxelGrid< pcl::PCLPointCloud2 > | VoxelGrid assembles a local 3D grid over a given PointCloud, and downsamples + filters the data |

pcl::apps::optronic_viewer::VoxelGridCF | Wrapper for a voxel grid filter. Divides the space in voxels and takes a point per voxel |

pcl::VoxelGridCovariance< PointT > | A searchable voxel strucure containing the mean and covariance of the data |

pcl::modeler::VoxelGridDownampleWorker | |

pcl::cloud_composer::VoxelGridDownsampleTool | |

pcl::cloud_composer::VoxelGridDownsampleToolFactory | |

pcl::VoxelGridLabel | |

pcl::VoxelGridOcclusionEstimation< PointT > | VoxelGrid to estimate occluded space in the scene. The ray traversal algorithm is implemented by the work of 'John Amanatides and Andrew Woo, A Fast Voxel Traversal Algorithm for Ray Tracing' |

pcl::recognition::VoxelStructure< T, REAL > | This class is a box in R3 built of voxels ordered in a regular rectangular grid. Each voxel is of type T |

pcl::cloud_composer::VPtr< T > | Templated helper class for converting QVariant to/from pointer classes |

pcl::VTKUtils | |

vtkVertexBufferObject | |

vtkVertexBufferObjectMapper | |

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::visualization::Window | |

pcl::cloud_composer::WorkQueue | |

Writer | |

testing::internal::XmlUnitTestResultPrinter | |

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 |

z_stream_s | |

pcl::occlusion_reasoning::ZBuffering< ModelT, SceneT > | Class to reason about occlusions |