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