[go: nahoru, domu]
Jump to content

Point Cloud Library: Difference between revisions

From Wikipedia, the free encyclopedia
Browse history interactively
← Previous edit
Content deleted Content added
VisualWikitext
Stable release: use wikidata
 
(55 intermediate revisions by 32 users not shown)
Line 1: Line 1:
{{Short description|Open-source algorithm library}}
{{third-party|date=October 2014}}
{{Infobox software
{{Infobox software
| logo = [[Image:Pcl (PointClouds library) logo with text.png|80px]]
| logo = Pcl (PointClouds library) logo with text.png
| author = [[Willow Garage]]
| author = [[Willow Garage]]
| operating system = [[Cross-platform]]
| operating system = [[Cross-platform]]
| released = {{Start date and age|2010|03}}<ref name=history>{{cite web|last=B. Rusu|first=Radu|title=PointClouds.org: A new home for Point Cloud Library (PCL)|url=http://www.willowgarage.com/blog/2011/03/27/point-cloud-library-pcl-moved-pointcloudsorg|publisher=Willow Garage|access-date=26 November 2012|date=28 March 2011}}</ref><ref name=firstrelease>{{cite web|title=PCL 1.0!|url=http://www.pointclouds.org/news/2011/05/12/pcl-1.0/|publisher=PCL|access-date=24 May 2013|date=12 May 2011}}{{Webarchive|url=https://web.archive.org/web/20200106210040/https://pointclouds.org/news/2011/05/12/pcl-1.0/ |date=2020-01-06 }}</ref>
| latest_release_version = 1.7.1
| latest_release_version = {{wikidata|property|preferred|references|edit|P348|P548=Q2804309}}
| latest_release_date = {{release date|2013|10|07}}
| latest_release_date = {{Start date and age|{{wikidata|qualifier|preferred|single|P348|P548=Q2804309|P577}}|df=yes}}<ref>{{Cite web|url=https://github.com/PointCloudLibrary/pcl/releases|title = Releases · PointCloudLibrary/PCL| website=[[GitHub]] }}</ref>
| genre = Library
| genre = Library
| license = [[BSD license]]
| license = [[BSD license]]
| website = {{url|http://pointclouds.org/}}
| website = {{url|pointclouds.org}}
}}
}}
'''PCL''' ('''Point Cloud Library''')<ref>PointClouds official website: http://www.pointclouds.org</ref> is a standalone [[open-source software|open-source]] [[software framework|framework]] including numerous state of the art algorithms for ''n''-dimensional [[point cloud]]s and 3D [[geometry processing]]. The library contains algorithms for filtering, feature estimation, surface reconstruction, [[image registration|registration]], [[model fitting]], and [[image segmentation|segmentation]]. PCL is developed by a large consortium of researchers and engineers around the world. It is written in [[C++]] and released under the [[BSD license]]. These algorithms can be used, for example, for [[perception]] in [[robotics]] to filter outliers from noisy data, stitch 3D point clouds together, segment relevant parts of a scene, extract keypoints and compute descriptors to recognize objects in the world based on their geometric appearance, and create surfaces from point clouds and visualize them.<ref>Robot Operating System: http://www.ros.org/wiki</ref>
The '''Point Cloud Library''' ('''PCL''') is an [[open-source software|open-source]] [[software library|library]] of algorithms for [[point cloud]] processing tasks and 3D [[geometry processing]], such as occur in three-dimensional [[computer vision]]. The library contains algorithms for filtering, feature estimation, surface reconstruction, [[Point set registration|3D registration]],<ref name=PCL-Tutorial>{{cite journal|last1=Holz|first1=Dirk|last2=Ichim |first2= Alexandru E.|last3=Tombari|first3=Federico| last4=Rusu|first4= Radu B.| last5= Behnke |first5=Sven|title= Registration with the Point Cloud Library: A Modular Framework for Aligning in 3-D | journal=IEEE Robotics Automation Magazine|date=2015|volume=22|issue=4|pages=110–124|doi= 10.1109/MRA.2015.2432331|s2cid=2621807|url= https://www.researchgate.net/publication/283198426 }}</ref> [[model fitting]], [[Object Recognition|object recognition]], and [[image segmentation|segmentation]]. Each module is implemented as a smaller library that can be compiled separately (for example, libpcl_filters, libpcl_features, libpcl_surface, ...). PCL has its own data format for storing point clouds - '''PCD''' (Point Cloud Data), but also allows datasets to be loaded and saved in many other formats. It is written in [[C++]] and released under the [[BSD license]].
==History==
The development of the Point Cloud Library started in March 2010 at [[Willow Garage]]. The project initially resided on a sub domain of Willow Garage then moved to a new website www.pointclouds.org in March 2011.<ref>{{cite web|last=B. Rusu|first=Radu|title=PointClouds.org: A new home for Point Cloud Library (PCL)|url=http://www.willowgarage.com/blog/2011/03/27/point-cloud-library-pcl-moved-pointcloudsorg|publisher=Willow Garage|accessdate=26 November 2012|date=28 March 2011}}</ref> PCL's first official release (Version 1.0) was released two months later in May 2011.<ref>{{cite web|title=PCL 1.0!|url=http://www.pointclouds.org/news/2011/05/12/pcl-1.0/|publisher=PCL|accessdate=24 May 2013|date=12 May 2011}}</ref>
==Modules==


These algorithms have been used, for example, for [[perception]] in [[robotics]] to filter outliers from noisy data, [[Point set registration|stitch 3D point clouds together]], segment relevant parts of a scene, extract keypoints and compute descriptors to recognize objects in the world based on their geometric appearance, and create surfaces from point clouds and visualize them.<ref>Robot Operating System: http://www.ros.org/wiki</ref>{{failed verification|date=June 2014}}
PCL is split into a number of modular libraries.<ref>PCL documentation and tutorials: http://pointclouds.org/documentation/</ref> The most important set of released PCL modules is shown below:


PCL requires several [[Third-party software component|third-party]] libraries to function, which must be installed. Most mathematical operations are implemented using the [[Eigen (C++ library)|Eigen]] library. The visualization module for 3D point clouds is based on [[VTK]]. [[Boost (C++ libraries)|Boost]] is used for shared pointers and the [[FLANN]] library for quick k-nearest neighbor search. Additional libraries such as Qhull, [[OpenNI]], or [[Qt (software)|Qt]] are optional and extend PCL with additional features.
===Filters===


PCL is [[cross-platform software]] that runs on the most commonly used [[operating system]]s: [[Linux]], [[Microsoft Windows|Windows]], [[macOS]] and [[Android (operating system)|Android]]. The library is fully integrated with the [[Robot Operating System]] (ROS) and provides support for [[OpenMP]] and [[Intel]] [[Threading Building Blocks]] (TBB) libraries for multi-core [[Parallel computing|parallelism]].<ref>{{Cite book|last=Hsieh|first=C.|title=2012 International Symposium on Intelligent Signal Processing and Communications Systems |chapter=An efficient development of 3D surface registration by Point Cloud Library (PCL) |date=2012|chapter-url=https://ieeexplore.ieee.org/document/6473587|pages=729–734|doi=10.1109/ISPACS.2012.6473587|isbn=978-1-4673-5082-2|s2cid=5449026}}</ref><ref name=":1" />
Noise removal is an example of a filter presented in PCL. Due to measurement errors, certain datasets present a large number of shadow points. This complicates the estimation of local point cloud 3D features. Some of these outliers can be filtered by performing a statistical analysis on each point’s neighborhood, and trimming those that do not meet a certain criteria. The sparse outlier removal implementation in PCL is based on the computation of the distribution of point to neighbor distances in the input dataset. For each point, the mean distance from it to all its neighbors is computed. By assuming that the resulting distribution is [[Normal distribution|Gaussian]] with a mean and a standard deviation, all points whose mean distances are outside an interval defined by the global distances mean and standard deviation can be considered as outliers and trimmed from the dataset.


The library is constantly updated and expanded, and its use in various industries is constantly growing. For example, PCL participated in the [[Google Summer of Code]] 2020 initiative with three projects. One was the extension of PCL for use with [[Python (programming language)|Python]] using Pybind11.<ref>{{Cite web|title=Google Summer of Code 2020|url=https://pointcloudlibrary.github.io/gsoc-2020/|access-date=2020-11-09|website=Point Cloud Library|language=en}}</ref>
===Features===


A large number of examples and tutorials are available on the PCL website, either as C++ source files or as tutorials with a detailed description and explanation of the individual steps.
The {{code|features}} library contains data structures and mechanisms for 3D feature estimation from point cloud data. 3D features are representations at certain 3D points, or positions, in space, which describe geometrical patterns based on the information available around the point. The data space selected around the query point is usually referred to as the k-neighborhood.
Two of the most widely used geometric point features are the underlying surface’s estimated curvature and normal at a query point p. Both of them are considered local features, as they characterize a point using the information provided by its k closest point neighbors. For determining these neighbors efficiently, the input dataset is usually split into smaller chunks using spatial decomposition techniques such as octrees or kD-trees, and then closest point searches are performed in that space. Depending on the application one can opt for either determining a fixed number of k points in the vicinity of p, or all points which are found inside of a sphere of radius r centered at p. One the easiest methods for estimating the surface normals and curvature changes at a point p is to perform an eigendecomposition (i.e., compute the eigenvectors and eigenvalues) of the k-neighborhood point surface patch.


===Keypoints===
== Applications ==
Point cloud library is widely used in many different fields, here are some examples:


* stitching 3D point clouds together
The {{code|keypoints}} library contains implementations of two point cloud keypoint detection algorithms. Keypoints (also referred to as interest points) are points in an image or point cloud that are stable, distinctive, and can be identified using a well-defined detection criterion. Typically, the number of interest points in a point cloud will be much smaller than the total number of points in the cloud, and when used in combination with local feature descriptors at each keypoint, the keypoints and descriptors can be used to form a compact, yet descriptive, representation of the original data.
* recognize 3D objects on their geometric appearance
* filtering and smoothing out noisy data
* create surfaces from point clouds
* aligning a previously captured model of an object to some newly captured data
* cluster recognition and [[Six degrees of freedom|6DoF]] [[3D pose estimation|pose estimation]]
* point cloud streaming to mobile devices with real-time visualization


== 3rd party libraries ==
===Registration===
PCL requires for its installation several third-party libraries, which are listed below. Some libraries are optional and extend PCL with additional features. The PCL library is built with the [[CMake]] build system (http://www.cmake.org/) at least in version 3.5.0.<ref>{{Cite web|title=Building PCL's dependencies from source on Windows — Point Cloud Library 0.0 documentation|url=https://pcl.readthedocs.io/projects/tutorials/en/latest/compiling_pcl_dependencies_windows.html|access-date=2020-11-02|website=pcl.readthedocs.io}}</ref><ref name=":1">{{Cite book|last1=Rusu|first1=R. B.|last2=Cousins|first2=S.|title=2011 IEEE International Conference on Robotics and Automation |chapter=3D is here: Point Cloud Library (PCL) |date=2011|chapter-url=https://ieeexplore.ieee.org/document/5980567|pages=1–4|doi=10.1109/ICRA.2011.5980567|isbn=978-1-61284-386-5|s2cid=206849822}}</ref>
{{See also|Point set registration}}


Mandatory libraries:
Combining several datasets into a global consistent model is usually performed using a technique called [[point set registration]]. The key idea is to identify corresponding points between the data sets and find a transformation that minimizes the distance (alignment error) between corresponding points. This process is repeated, since correspondence search is affected by the relative position and orientation of the data sets. Once the alignment errors fall below a given threshold, the registration is said to be complete.
The registration library implements a plethora of point cloud registration algorithms for both organized and unorganized (general purpose) datasets. For instance, PCL contains a set of powerful algorithms that allow the estimation of multiple sets of correspondences, as well as methods for rejecting bad correspondences, and estimating transformations in a robust manner.


* '''[[Boost (C++ libraries)|Boost]]''' (http://www.boost.org/) at least version 1.46.1. This set of C++ libraries is used for threading and mainly for shared pointers, so there is no need to re-copy data that is already in the system.
==={{vanchor|KdTree}}===
* '''[[Eigen (C++ library)|Eigen]]''' (http://eigen.tuxfamily.org/) is required at least in version 3.0.0. It is an open-source template library for linear algebra (matrices, vectors). Most mathematical operations ([[Streaming SIMD Extensions|SSE]] optimized) in PCL are implemented with Eigen.
* '''FLANN''' (http://www.cs.ubc.ca/research/flann/) in version 1.6.8 or higher. It is a library that performs a fast approximate nearest neighbor search in high dimensional spaces. In PCL, it is especially important in the kdtree module for fast k-nearest neighbor search operations.
* '''[[VTK|VTK - Visualization ToolKit]]''' (http://www.vtk.org/) at least version 5.6.1. Multi-platform software system for rendering 3D point cloud, modeling, image processing, volume rendering. Used in visualization module for point cloud rendering and visualization.


Optional libraries that enable some additional features:
The PCL {{code|kdtree}} library provides the kd-tree data-structure, using FLANN, that allows for fast nearest neighbor searches.
A [[Kd-tree]] (k-dimensional tree) is a space-partitioning data structure that stores a set of k-dimensional points in a tree structure that enables efficient range searches and nearest neighbor searches. Nearest neighbor searches are a core operation when working with point cloud data and can be used to find correspondences between groups of points or feature descriptors or to define the local neighborhood around a point or points.


* '''QHULL''' in version >= 2011.1 (http://www.qhull.org/) implements computation of the convex hull, Delaunay triangulation, Voronoi diagram, and so on. In PCL it is used for convex/concave hull decomposition on the surface.
==={{vanchor|Octree}}===
* '''[[OpenNI]]''' in version >= 1.1.0.25 (http://www.openni.org/) provides a single unified interface to depth sensors. It is used to retrieve point clouds from devices.
* '''[[Qt (software)|Qt]]''' version >= 4.6 (https://www.qt.io/) is a cross-platform C++ framework used for developing applications with a graphical user interface (GUI).
* '''[[Google Test|Googletest]]''' in version >= 1.6.0 (http://code.google.com/p/googletest/) is a C++ testing framework. In PCL, it is used to build test units.


==PCD File Format==
The {{code|octree}} library provides efficient methods for creating a hierarchical tree data structure from point cloud data. This enables spatial partitioning, downsampling and search operations on the point data set. Each [[octree]] node has either eight children or no children. The root node describes a cubic bounding box which encapsulates all points. At every tree level, this space becomes subdivided by a factor of 2 which results in an increased voxel resolution.
The '''PCD''' ('''Point Cloud Data''') is a file format for storing 3D point cloud data. It was created because existing formats did not support some of the features provided by the PCL library. PCD is the primary data format in PCL, but the library also offers the ability to save and load data in other formats (such as PLY, IFS, VTK, STL, OBJ, X3D). However, these other formats do not have the flexibility and speed of PCD files. One of the PCD advantages is the ability to store and process organized point cloud datasets. Another is very fast saving and loading of points that are stored in binary form.<ref name=":0">{{Cite web|title=The PCD (Point Cloud Data) file format — Point Cloud Library 0.0 documentation|url=https://pcl.readthedocs.io/projects/tutorials/en/latest/pcd_file_format.html|access-date=2020-11-02|website=pcl.readthedocs.io}}</ref><ref>{{Cite web|url=https://pcl.readthedocs.io/projects/tutorials/en/latest/pcd_file_format.html|title = The PCD (Point Cloud Data) file format — Point Cloud Library 0.0 documentation}}</ref>
The octree implementation provides efficient nearest neighbor search routines, such as “Neighbors within Voxel Search”, “K Nearest Neighbor Search” and “Neighbors within Radius Search”. It automatically adjusts its dimension to the point data set. A set of leaf node classes provide additional functionality, such as spacial “occupancy” and “point density per voxel” checks. Functions for serialization and deserialization enable to efficiently encode the octree structure into a binary format. Furthermore, a memory pool implementation reduces expensive memory allocation and deallocation operations in scenarios where octrees need to be created at a high rate.


===Segmentation===
=== Versions ===
The PCD version is specified with the numbers 0.x (e.g., 0.5, 0.6, etc.) in the header of each file. The official version in 2020 is PCD '''0.7''' ('''PCD_V7'''). The main difference compared to version 0.6 is that a new header - VIEWPOINT has been added. It specifies the information about the orientation of the sensor relative to the dataset.<ref>{{Cite web|title=Point Cloud Library (PCL): pcl::PCDReader Class Reference|url=https://pointclouds.org/documentation/classpcl_1_1_p_c_d_reader.html|access-date=2020-11-02|website=pointclouds.org}}</ref>


=== File structure ===
The {{code|segmentation}} library contains algorithms for segmenting a point cloud into distinct clusters. These algorithms are best suited for processing a point cloud that is composed of a number of spatially isolated regions. In such cases, clustering is often used to break the cloud down into its constituent parts, which can then be processed independently.
The PCD file is divided into two parts - '''header''' and '''data'''. The header has a precisely defined format and contains the necessary information about the point cloud data that are stored in it. The header must be encoded in ASCII, however, the data can be stored in ASCII or binary format. Thanks to the fact that the ASCII format is more human readable, it can be opened in standard software tools and easily edited.


In version 0.7 the ''version'' of the PCD file is at the beginning of the header, followed by the ''name'', ''size'', and ''type'' of each dimension of the stored data. It also shows a number of points (''height''*''width'') in the whole cloud and information about whether the point cloud dataset is organized or unorganized. The ''data'' type specifies in which format the point cloud data are stored (ASCII or binary). The header is followed by a set of points. Each point can be stored on a separate line (unorganized point-cloud) or they are stored in an image-like organized structure (organized point-cloud).<ref name=":0" /> More detailed information about header entries can be found in [https://pcl.readthedocs.io/projects/tutorials/en/latest/pcd_file_format.html documentation]. Below is an example of a PCD file. The order of header entries is important!
===Sample Consensus===
# .PCD v.7 - Point Cloud Data file format
VERSION .7
FIELDS x y z rgb
SIZE 4 4 4 4
TYPE F F F F
COUNT 1 1 1 1
WIDTH 213
HEIGHT 1
VIEWPOINT 0 0 0 1 0 0 0
POINTS 213
DATA ascii
0.93773 0.33763 0 4.2108e+06
0.90805 0.35641 0 4.2108e+06
0.81915 0.32 0 4.2108e+06
0.97192 0.278 0 4.2108e+06
...
...


==History==
The {{code|sample_consensus}} library holds SAmple Consensus (SAC) methods like [[RANSAC]] and models like planes and cylinders. These can be combined freely in order to detect specific models and their parameters in point clouds.
The development of the Point Cloud Library started in March 2010 at [[Willow Garage]]. The project initially resided on a sub domain of Willow Garage then moved to a new website www.pointclouds.org in March 2011.<ref name=history /> PCL's first official release (Version 1.0) was released two months later in May 2011.<ref name=firstrelease />
Some of the models implemented in this library include: lines, planes, cylinders, and spheres. Plane fitting is often applied to the task of detecting common indoor surfaces, such as walls, floors, and table tops. Other models can be used to detect and segment objects with common geometric structures (e.g., fitting a cylinder model to a mug).


===Surface===
== Modules ==
PCL is divided into several smaller code libraries that can be compiled separately. Some of the most important modules and their functions are described below.<ref>{{Cite web|title=PCL Walkthrough — Point Cloud Library 0.0 documentation|url=https://pcl.readthedocs.io/projects/tutorials/en/latest/walkthrough.html|access-date=2020-11-03|website=pcl.readthedocs.io}}</ref><ref>{{Cite web|title=Introduction — Point Cloud Library 0.0 documentation|url=https://pcl.readthedocs.io/projects/tutorials/en/latest/|access-date=2020-11-04|website=pcl.readthedocs.io}}</ref>


=== Filters ===
The {{code|surface}} library deals with reconstructing the original surfaces from 3D scans. Depending on the task at hand, this can be for example the hull, a mesh representation or a smoothed/resampled surface with normals.
When scanning a 3D point cloud, errors and various deviations can occur, which causes noise in the data. This complicates the estimation of some local point cloud characteristics, such as surface normals. These inaccuracies can lead to significant errors in further processing and it is therefore advisable to remove them with a suitable filter. The '''pcl_filters''' library provides several useful filters for removing outliers and noise and also downsampling the data. Some of them use simple criteria to trim points, others use statistical analysis.
Smoothing and resampling can be important if the cloud is noisy, or if it is composed of multiple scans that are not aligned perfectly. The complexity of the surface estimation can be adjusted, and normals can be estimated in the same step if needed.
Meshing is a general way to create a surface out of points, and currently there are two algorithms provided: a very fast triangulation of the original points, and a slower meshing that does smoothing and hole filling as well.
Creating a convex or concave hull is useful for example when there is a need for a simplified surface representation or when boundaries need to be extracted.


* '''PassThrough''' filter - is used to filter points in one selected dimension. This means that it can cut off points that are not within the range specified by the user.
===Range Image===
* '''VoxelGrid''' filter - creates a grid of voxels in a point cloud. The points inside each voxel are then approximated by their centroid. This leads to downsampling (reduction of the number of points) in the point cloud data.
* '''StatisticalOutlierRemoval''' filter - It removes noise from a point cloud dataset using statistical analysis techniques applied to each point's neighborhood and trim all points whose mean distances are outside a defined interval.
* '''RadiusOutlierRemoval''' filter - removes those points that have less than the selected number of neighbors in the defined neighborhood.


=== Features ===
The {{code|range_image}} library contains two classes for representing and working with range images. A range image (or depth map) is an image whose pixel values represent a distance or depth from the sensor’s origin. Range images are a common 3D representation and are often generated by stereo or [[time-of-flight camera]]s. With knowledge of the camera’s intrinsic calibration parameters, a range image can be converted into a point cloud.
The '''pcl_features''' library contains algorithms and data structures for 3D [[Feature geometry|feature]] estimation. Mostly used local geometric features are the point normal and underlying surface's estimated curvature. The features describe geometrical patterns at a certain point based on selected k-neighborhood (data space selected around the point). The neighborhood can be selected by determining a fixed number of points in the closest area or defining a radius of a sphere around the point.


One of the easiest implemented methods for estimating the surface normal is an analysis of the [[eigenvectors]] and [[Eigenvalues and eigenvectors|eigenvalues]] of a [[covariance matrix]] created from the neighborhood of the point. Point Feature Histograms (or faster FPFH) descriptors are an advanced feature representation and depend on normal estimations at each point. It generalizes the mean curvature around the point using a multidimensional histogram of values. Some of other descriptors in the library are Viewpoint Feature Histogram (VFH) descriptor, NARF descriptors, Moment of inertia and eccentricity based descriptors, Globally Aligned Spatial Distribution (GASD) descriptors, and more.
===IO===


=== Segmentation ===
The {{code|io}} library contains classes and functions for reading and writing point cloud data (PCD) files, as well as capturing point clouds from a variety of sensing devices. <!-- An introduction to some of these capabilities can be found in the following tutorials: (which ones?) -->
The '''pcl_segmentation''' library contains algorithms for segmenting a point cloud into different clusters. Clustering is often used to divide the cloud into individual parts, that can be further processed. There are implemented several classes, that support various segmentation methods:


* '''Plane model''' segmentation - simple algorithm that finds all the points that support a plane model in the point cloud
===Visualization===
* '''Euclidean''' clustering - creates clusters of points based on Euclidean distance
* '''Conditional Euclidean''' clustering - clustering points based on Euclidean distance and a user-defined condition
* '''Region growing''' segmentation - merge the points that are close enough in terms of the smoothness constraint
* '''Color-based region growing''' segmentation - same concept as the Region growing, but uses color instead of normals
* '''Min-Cut''' based binary segmentation - divides the cloud on foreground and background sets of points
* '''Difference of Normals''' Based Segmentation - scale based segmentation, finding points that belong within the scale parameters given
* '''Supervoxel''' clustering - generates volumetric over-segmentations of 3D point cloud data


=== Visualization ===
The {{code|visualization}} library was built to allow rapid prototyping and visualization of algorithms operating on 3D point cloud data. Similar to OpenCV’s highgui routines for displaying 2D images and for drawing basic 2D shapes on screen, the library offers: a) methods for rendering and setting visual properties (colors, point sizes, opacity, etc) for any n-D point cloud datasets in pcl::PointCloud<T> format; b) methods for drawing basic 3D shapes on screen (e.g., cylinders, spheres, lines, polygons, etc) either from sets of points or from parametric equations; c) a histogram visualization module (PCLHistogramVisualizer) for 2D plots; d) a multitude of Geometry and Color handlers for pcl::PointCloud<T> datasets; e) a pcl::RangeImage visualization module.
The '''pcl_visualization''' library is used to quickly and easily visualize 3D point cloud data. The package makes use of the VTK library for 3D rendering of clouds and range images. The library offers:


* The '''CloudViewer''' class is for a simple point cloud visualization.
===Common===
* '''RangeImageVisualizer''' can be used to visualize a range image as a 3D point cloud or as a picture where the colors correspond to range values.
* '''PCLVisualizer''' is a visualization class with several applications. It can display both simple point cloud and point cloud that contains colour data. Unlike CloudViewer, it can also draw interesting point cloud information such as normals, principal curvatures and geometries. It can display multiple point clouds side-by-side so they can be easily compared, or draw various primitive shapes (e.g., cylinders, spheres, lines, polygons, etc.) either from sets of points or from parametric equations.
* '''PCLPlotter''' class is used for easy plotting graphs, from polynomial functions to histograms. It can process different types of plot input (coordinates, functions) and does auto-coloring.
* '''PCLHistogramVisualizer''' is a histogram visualization module for 2D plots.


=== Registration ===
The {{code|common}} library contains the common data structures and methods used by the majority of PCL libraries. The core data structures include the PointCloud class and a multitude of point types that are used to represent points, surface normals, RGB color values, feature descriptors, etc. It also contains numerous functions for computing distances/norms, means and covariances, angular conversions, geometric transformations, and more.
[[Point set registration|Registration]] is the problem of aligning various point cloud datasets acquired from different views into a single point cloud model. The '''pcl_registration''' library implements number of point cloud registration algorithms for both organized and unorganized datasets. The task is to identify the corresponding points between the data sets and find a transformation that minimizes their distance.


The [[iterative closest point]] algorithm minimizes the distances between the points of two pointclouds. It can be used for determining if one PointCloud is just a rigid transformation of another. [[Normal Distributions Transform]] (NDT) is a registration algorithm that can be used to determine a rigid transformation between two point clouds that have over 100,000 points.
===Search===


=== Sample Consensus ===
The {{code|search}} library provides methods for searching for nearest neighbors using different data structures, including: [[&#35;KdTree]], [[&#35;Octree]], brute force, and specialized search for organized datasets.
The '''''sample_consensus''''' library holds SAmple Consensus (SAC) methods like RANSAC and models to detect specific objects in point clouds. Some of the models implemented in this library include plane models that are often used to detect interior surfaces such as walls and floors. Next models are the lines, 2D and 3D circles in a plane, sphere, cylinder, cone, a model for determining a line parallel with a given axis, a model for determining a plane perpendicular to a user-specified axis, plane parallel to a user-specified axis, etc. These can be used to detect objects with common geometric structures (e.g., fitting a cylinder model to a mug).

Robust sample consensus estimators that are available in the library:

* [[RANSAC|SAC_RANSAC]] - RANdom SAmple Consensus
* SAC_LMEDS - Least Median of Squares
* SAC_MSAC - M-Estimator SAmple Consensus
* SAC_RRANSAC - Randomized RANSAC
* SAC_RMSAC - Randomized MSAC
* SAC_MLESAC - Maximum LikeLihood Estimation SAmple Consensus
* SAC_PROSAC - PROgressive SAmple Consensus

=== Surface ===

Several algorithms for surface reconstruction of 3D point clouds are implemented in the '''pcl_surface''' library. There are several ways to reconstruct the surface. One of the most commonly used is meshing, and the PCL library has two algorithms: very fast triangulation of original points and slower networking, which also smooths and fills holes. If the cloud is noisy, it is advisable to use surface smoothing using one of the implemented algorithms.

The [[Moving least squares|Moving Least Squares]] (MLS) surface reconstruction method is a resampling algorithm that can reconstruct missing parts of a surface. Thanks to higher order polynomial interpolations between surrounding data points, MLS can correct and smooth out small errors caused by scanning.

[[Greedy triangulation|Greedy Projection Triangulation]] implements an algorithm for fast surface triangulation on an unordered PointCloud with normals. The result is a triangle mesh that is created by projecting the local neighborhood of a point along the normal of the point. It works best if the surface is locally smooth and there are smooth transitions between areas with different point densities. Many parameters can be set that are taken into account when connecting points (how many neighbors are searched, the maximum distance for a point, minimum and maximum angle of a triangle).

The library also implements functions for creating a [[Concave polygon|concave]] or [[convex hull]] polygon for a plane model, Grid projection surface reconstruction algorithm, [[marching cubes]], [[ear clipping]] triangulation algorithm, [[Poisson surface reconstruction]] algorithm, etc.

=== I/O ===
The '''io_library''' allows you to load and save point clouds to files, as well as capture clouds from various devices. It includes functions that allow you to concatenate the points of two different point clouds with the same type and number of fields. The library can also concatenate fields (e.g., dimensions) of two different point clouds with same number of points.

Starting with '''PCL 1.0''' the library offers a new generic grabber interface that provides easy access to different devices and file formats. The first devices supported for data collection were [[OpenNI]] compatible cameras (tested with ''Primesense Reference Design'', ''Microsoft Kinect'' and ''Asus Xtion Pro cameras''). As of '''PCL 1.7''', point cloud data can be also obtained from the [[Velodyne LiDAR|Velodyne High Definition LiDAR]] (HDL) system, which produces 360 degree point clouds. PCL supports both the original ''HDL-64e'' and ''HDL-32e''. There is also a new driver for [http://dinast.com/ Dinast] Cameras (tested with ''IPA-1110'', ''Cyclopes II'' and ''IPA-1002 ng T-Less NG''). '''PCL 1.8''' brings support for IDS-Imaging [https://en.ids-imaging.com/ Ensenso] cameras, [[DepthSense]] cameras (e.g. ''Creative Senz3D'', ''DepthSense DS325''), and [http://www.david-3d.com/en/products/david-sdk davidSDK] scanners.

=== KdTree ===
The '''pcl_kdtree''' library provides the [[K-d tree|kd-tree]] data-structure for organizing a set of points in a space with k dimensions. Used to find the K nearest neighbors (using FLANN) of a specific point or location.

=== Octree ===
The '''pcl_octree''' library implements the [[octree]] hierarchical tree data structure for point cloud data. The library provides nearest neighbor search algorithms, such as “Neighbors within Voxel Search”, “K Nearest Neighbor Search” and “Neighbors within Radius Search”. There are also several octree types that differ by their leaf node's properties. Each leaf node can hold a single point or a list of point indices, or it does not store any point information. The library can be also used for detection of spatial changes between multiple unorganized point clouds by recursive comparison of octet tree structures.

=== Search ===
The '''pcl_search''' library implements methods for searching for nearest neighbors using different data structures, that can be found in other modules, such as KdTree, Octree, or specialized search for organized datasets.

=== Range Image ===
The '''range_image''' library contains two classes for representing and working with range images whose pixel values represent a distance from the sensor. The range image can be converted to a point cloud if the sensor position is specified or the borders can be extracted from it.

=== Keypoints ===
The '''pcl_keypoints''' library contains implementations of point cloud keypoint detection algorithms (AGAST corner point detector, [[Harris Corner Detector|Harris detector]], BRISK detector, etc.).

=== Common ===
The '''pcl_common''' library contains the core data structures for point cloud, types for point representation, surface normals, RGB color values, etc. There are also implemented useful methods for computing distances, mean values and covariance, geometric transformations, and more. The common library is mainly used by other PCL modules.


==References==
==References==
Line 85: Line 175:


== External links ==
== External links ==
* [http://www.openperception.org Open Perception Inc]
* [https://pointclouds.org/ Point Cloud Library]
* [http://www.pcl-users.org Point Cloud Library (PCL) Users]
* [http://www.pcl-users.org Point Cloud Library (PCL) Users]
*[https://github.com/PointCloudLibrary GitHub Repository]
* [http://www.pcl-developers.org Point Cloud Library (PCL) Developers]
*[https://pcl.readthedocs.io/ Tutorials]

{{3D software}}
{{3D software}}


Line 95: Line 185:
[[Category:Free 3D graphics software]]
[[Category:Free 3D graphics software]]
[[Category:Free software programmed in C++]]
[[Category:Free software programmed in C++]]
[[Category:Software using the BSD license]]
[[Category:Point (geometry)]]

Latest revision as of 15:42, 19 May 2024

Point Cloud Library
Original author(s)Willow Garage
Initial releaseMarch 2010; 14 years ago (2010-03)[1][2]
Stable release
1.14.1[3] Edit this on Wikidata / 3 May 2024; 2 months ago (3 May 2024)[4]
Repository
Operating systemCross-platform
TypeLibrary
LicenseBSD license
Websitepointclouds.org

The Point Cloud Library (PCL) is an open-source library of algorithms for point cloud processing tasks and 3D geometry processing, such as occur in three-dimensional computer vision. The library contains algorithms for filtering, feature estimation, surface reconstruction, 3D registration,[5] model fitting, object recognition, and segmentation. Each module is implemented as a smaller library that can be compiled separately (for example, libpcl_filters, libpcl_features, libpcl_surface, ...). PCL has its own data format for storing point clouds - PCD (Point Cloud Data), but also allows datasets to be loaded and saved in many other formats. It is written in C++ and released under the BSD license.

These algorithms have been used, for example, for perception in robotics to filter outliers from noisy data, stitch 3D point clouds together, segment relevant parts of a scene, extract keypoints and compute descriptors to recognize objects in the world based on their geometric appearance, and create surfaces from point clouds and visualize them.[6][failed verification]

PCL requires several third-party libraries to function, which must be installed. Most mathematical operations are implemented using the Eigen library. The visualization module for 3D point clouds is based on VTK. Boost is used for shared pointers and the FLANN library for quick k-nearest neighbor search. Additional libraries such as Qhull, OpenNI, or Qt are optional and extend PCL with additional features.

PCL is cross-platform software that runs on the most commonly used operating systems: Linux, Windows, macOS and Android. The library is fully integrated with the Robot Operating System (ROS) and provides support for OpenMP and Intel Threading Building Blocks (TBB) libraries for multi-core parallelism.[7][8]

The library is constantly updated and expanded, and its use in various industries is constantly growing. For example, PCL participated in the Google Summer of Code 2020 initiative with three projects. One was the extension of PCL for use with Python using Pybind11.[9]

A large number of examples and tutorials are available on the PCL website, either as C++ source files or as tutorials with a detailed description and explanation of the individual steps.

Applications[edit]

Point cloud library is widely used in many different fields, here are some examples:

  • stitching 3D point clouds together
  • recognize 3D objects on their geometric appearance
  • filtering and smoothing out noisy data
  • create surfaces from point clouds
  • aligning a previously captured model of an object to some newly captured data
  • cluster recognition and 6DoF pose estimation
  • point cloud streaming to mobile devices with real-time visualization

3rd party libraries[edit]

PCL requires for its installation several third-party libraries, which are listed below. Some libraries are optional and extend PCL with additional features. The PCL library is built with the CMake build system (http://www.cmake.org/) at least in version 3.5.0.[10][8]

Mandatory libraries:

  • Boost (http://www.boost.org/) at least version 1.46.1. This set of C++ libraries is used for threading and mainly for shared pointers, so there is no need to re-copy data that is already in the system.
  • Eigen (http://eigen.tuxfamily.org/) is required at least in version 3.0.0. It is an open-source template library for linear algebra (matrices, vectors). Most mathematical operations (SSE optimized) in PCL are implemented with Eigen.
  • FLANN (http://www.cs.ubc.ca/research/flann/) in version 1.6.8 or higher. It is a library that performs a fast approximate nearest neighbor search in high dimensional spaces. In PCL, it is especially important in the kdtree module for fast k-nearest neighbor search operations.
  • VTK - Visualization ToolKit (http://www.vtk.org/) at least version 5.6.1. Multi-platform software system for rendering 3D point cloud, modeling, image processing, volume rendering. Used in visualization module for point cloud rendering and visualization.

Optional libraries that enable some additional features:

  • QHULL in version >= 2011.1 (http://www.qhull.org/) implements computation of the convex hull, Delaunay triangulation, Voronoi diagram, and so on. In PCL it is used for convex/concave hull decomposition on the surface.
  • OpenNI in version >= 1.1.0.25 (http://www.openni.org/) provides a single unified interface to depth sensors. It is used to retrieve point clouds from devices.
  • Qt version >= 4.6 (https://www.qt.io/) is a cross-platform C++ framework used for developing applications with a graphical user interface (GUI).
  • Googletest in version >= 1.6.0 (http://code.google.com/p/googletest/) is a C++ testing framework. In PCL, it is used to build test units.

PCD File Format[edit]

The PCD (Point Cloud Data) is a file format for storing 3D point cloud data. It was created because existing formats did not support some of the features provided by the PCL library. PCD is the primary data format in PCL, but the library also offers the ability to save and load data in other formats (such as PLY, IFS, VTK, STL, OBJ, X3D). However, these other formats do not have the flexibility and speed of PCD files. One of the PCD advantages is the ability to store and process organized point cloud datasets. Another is very fast saving and loading of points that are stored in binary form.[11][12]

Versions[edit]

The PCD version is specified with the numbers 0.x (e.g., 0.5, 0.6, etc.) in the header of each file. The official version in 2020 is PCD 0.7 (PCD_V7). The main difference compared to version 0.6 is that a new header - VIEWPOINT has been added. It specifies the information about the orientation of the sensor relative to the dataset.[13]

File structure[edit]

The PCD file is divided into two parts - header and data. The header has a precisely defined format and contains the necessary information about the point cloud data that are stored in it. The header must be encoded in ASCII, however, the data can be stored in ASCII or binary format. Thanks to the fact that the ASCII format is more human readable, it can be opened in standard software tools and easily edited.

In version 0.7 the version of the PCD file is at the beginning of the header, followed by the name, size, and type of each dimension of the stored data. It also shows a number of points (height*width) in the whole cloud and information about whether the point cloud dataset is organized or unorganized. The data type specifies in which format the point cloud data are stored (ASCII or binary). The header is followed by a set of points. Each point can be stored on a separate line (unorganized point-cloud) or they are stored in an image-like organized structure (organized point-cloud).[11] More detailed information about header entries can be found in documentation. Below is an example of a PCD file. The order of header entries is important! 

# .PCD v.7 - Point Cloud Data file format
VERSION .7
FIELDS x y z rgb
SIZE 4 4 4 4
TYPE F F F F
COUNT 1 1 1 1
WIDTH 213
HEIGHT 1
VIEWPOINT 0 0 0 1 0 0 0
POINTS 213
DATA ascii
0.93773 0.33763 0 4.2108e+06
0.90805 0.35641 0 4.2108e+06
0.81915 0.32 0 4.2108e+06
0.97192 0.278 0 4.2108e+06
...
...

History[edit]

The development of the Point Cloud Library started in March 2010 at Willow Garage. The project initially resided on a sub domain of Willow Garage then moved to a new website www.pointclouds.org in March 2011.[1] PCL's first official release (Version 1.0) was released two months later in May 2011.[2]

Modules[edit]

PCL is divided into several smaller code libraries that can be compiled separately. Some of the most important modules and their functions are described below.[14][15]

Filters[edit]

When scanning a 3D point cloud, errors and various deviations can occur, which causes noise in the data. This complicates the estimation of some local point cloud characteristics, such as surface normals. These inaccuracies can lead to significant errors in further processing and it is therefore advisable to remove them with a suitable filter. The pcl_filters library provides several useful filters for removing outliers and noise and also downsampling the data. Some of them use simple criteria to trim points, others use statistical analysis.

  • PassThrough filter - is used to filter points in one selected dimension. This means that it can cut off points that are not within the range specified by the user.
  • VoxelGrid filter - creates a grid of voxels in a point cloud. The points inside each voxel are then approximated by their centroid. This leads to downsampling (reduction of the number of points) in the point cloud data.
  • StatisticalOutlierRemoval filter - It removes noise from a point cloud dataset using statistical analysis techniques applied to each point's neighborhood and trim all points whose mean distances are outside a defined interval.
  • RadiusOutlierRemoval filter - removes those points that have less than the selected number of neighbors in the defined neighborhood.

Features[edit]

The pcl_features library contains algorithms and data structures for 3D feature estimation. Mostly used local geometric features are the point normal and underlying surface's estimated curvature. The features describe geometrical patterns at a certain point based on selected k-neighborhood (data space selected around the point). The neighborhood can be selected by determining a fixed number of points in the closest area or defining a radius of a sphere around the point.

One of the easiest implemented methods for estimating the surface normal is an analysis of the eigenvectors and eigenvalues of a covariance matrix created from the neighborhood of the point. Point Feature Histograms (or faster FPFH) descriptors are an advanced feature representation and depend on normal estimations at each point. It generalizes the mean curvature around the point using a multidimensional histogram of values. Some of other descriptors in the library are Viewpoint Feature Histogram (VFH) descriptor, NARF descriptors, Moment of inertia and eccentricity based descriptors, Globally Aligned Spatial Distribution (GASD) descriptors, and more.

Segmentation[edit]

The pcl_segmentation library contains algorithms for segmenting a point cloud into different clusters. Clustering is often used to divide the cloud into individual parts, that can be further processed. There are implemented several classes, that support various segmentation methods:

  • Plane model segmentation - simple algorithm that finds all the points that support a plane model in the point cloud
  • Euclidean clustering - creates clusters of points based on Euclidean distance
  • Conditional Euclidean clustering - clustering points based on Euclidean distance and a user-defined condition
  • Region growing segmentation - merge the points that are close enough in terms of the smoothness constraint
  • Color-based region growing segmentation - same concept as the Region growing, but uses color instead of normals
  • Min-Cut based binary segmentation - divides the cloud on foreground and background sets of points
  • Difference of Normals Based Segmentation - scale based segmentation, finding points that belong within the scale parameters given
  • Supervoxel clustering - generates volumetric over-segmentations of 3D point cloud data

Visualization[edit]

The pcl_visualization library is used to quickly and easily visualize 3D point cloud data. The package makes use of the VTK library for 3D rendering of clouds and range images. The library offers:

  • The CloudViewer class is for a simple point cloud visualization.
  • RangeImageVisualizer can be used to visualize a range image as a 3D point cloud or as a picture where the colors correspond to range values.
  • PCLVisualizer is a visualization class with several applications. It can display both simple point cloud and point cloud that contains colour data. Unlike CloudViewer, it can also draw interesting point cloud information such as normals, principal curvatures and geometries. It can display multiple point clouds side-by-side so they can be easily compared, or draw various primitive shapes (e.g., cylinders, spheres, lines, polygons, etc.) either from sets of points or from parametric equations.
  • PCLPlotter class is used for easy plotting graphs, from polynomial functions to histograms. It can process different types of plot input (coordinates, functions) and does auto-coloring.
  • PCLHistogramVisualizer is a histogram visualization module for 2D plots.

Registration[edit]

Registration is the problem of aligning various point cloud datasets acquired from different views into a single point cloud model. The pcl_registration library implements number of point cloud registration algorithms for both organized and unorganized datasets. The task is to identify the corresponding points between the data sets and find a transformation that minimizes their distance.

The iterative closest point algorithm minimizes the distances between the points of two pointclouds. It can be used for determining if one PointCloud is just a rigid transformation of another. Normal Distributions Transform (NDT) is a registration algorithm that can be used to determine a rigid transformation between two point clouds that have over 100,000 points.

Sample Consensus[edit]

The sample_consensus library holds SAmple Consensus (SAC) methods like RANSAC and models to detect specific objects in point clouds. Some of the models implemented in this library include plane models that are often used to detect interior surfaces such as walls and floors. Next models are the lines, 2D and 3D circles in a plane, sphere, cylinder, cone, a model for determining a line parallel with a given axis, a model for determining a plane perpendicular to a user-specified axis, plane parallel to a user-specified axis, etc. These can be used to detect objects with common geometric structures (e.g., fitting a cylinder model to a mug).

Robust sample consensus estimators that are available in the library:

  • SAC_RANSAC - RANdom SAmple Consensus
  • SAC_LMEDS - Least Median of Squares
  • SAC_MSAC - M-Estimator SAmple Consensus
  • SAC_RRANSAC - Randomized RANSAC
  • SAC_RMSAC - Randomized MSAC
  • SAC_MLESAC - Maximum LikeLihood Estimation SAmple Consensus
  • SAC_PROSAC - PROgressive SAmple Consensus

Surface[edit]

Several algorithms for surface reconstruction of 3D point clouds are implemented in the pcl_surface library. There are several ways to reconstruct the surface. One of the most commonly used is meshing, and the PCL library has two algorithms: very fast triangulation of original points and slower networking, which also smooths and fills holes. If the cloud is noisy, it is advisable to use surface smoothing using one of the implemented algorithms.

The Moving Least Squares (MLS) surface reconstruction method is a resampling algorithm that can reconstruct missing parts of a surface. Thanks to higher order polynomial interpolations between surrounding data points, MLS can correct and smooth out small errors caused by scanning.

Greedy Projection Triangulation implements an algorithm for fast surface triangulation on an unordered PointCloud with normals. The result is a triangle mesh that is created by projecting the local neighborhood of a point along the normal of the point. It works best if the surface is locally smooth and there are smooth transitions between areas with different point densities. Many parameters can be set that are taken into account when connecting points (how many neighbors are searched, the maximum distance for a point, minimum and maximum angle of a triangle).

The library also implements functions for creating a concave or convex hull polygon for a plane model, Grid projection surface reconstruction algorithm, marching cubes, ear clipping triangulation algorithm, Poisson surface reconstruction algorithm, etc.

I/O[edit]

The io_library allows you to load and save point clouds to files, as well as capture clouds from various devices. It includes functions that allow you to concatenate the points of two different point clouds with the same type and number of fields. The library can also concatenate fields (e.g., dimensions) of two different point clouds with same number of points.

Starting with PCL 1.0 the library offers a new generic grabber interface that provides easy access to different devices and file formats. The first devices supported for data collection were OpenNI compatible cameras (tested with Primesense Reference Design, Microsoft Kinect and Asus Xtion Pro cameras). As of PCL 1.7, point cloud data can be also obtained from the Velodyne High Definition LiDAR (HDL) system, which produces 360 degree point clouds. PCL supports both the original HDL-64e and HDL-32e. There is also a new driver for Dinast Cameras (tested with IPA-1110, Cyclopes II and IPA-1002 ng T-Less NG). PCL 1.8 brings support for IDS-Imaging Ensenso cameras, DepthSense cameras (e.g. Creative Senz3D, DepthSense DS325), and davidSDK scanners.

KdTree[edit]

The pcl_kdtree library provides the kd-tree data-structure for organizing a set of points in a space with k dimensions. Used to find the K nearest neighbors (using FLANN) of a specific point or location.

Octree[edit]

The pcl_octree library implements the octree hierarchical tree data structure for point cloud data. The library provides nearest neighbor search algorithms, such as “Neighbors within Voxel Search”, “K Nearest Neighbor Search” and “Neighbors within Radius Search”. There are also several octree types that differ by their leaf node's properties. Each leaf node can hold a single point or a list of point indices, or it does not store any point information. The library can be also used for detection of spatial changes between multiple unorganized point clouds by recursive comparison of octet tree structures.

Search[edit]

The pcl_search library implements methods for searching for nearest neighbors using different data structures, that can be found in other modules, such as KdTree, Octree, or specialized search for organized datasets.

Range Image[edit]

The range_image library contains two classes for representing and working with range images whose pixel values represent a distance from the sensor. The range image can be converted to a point cloud if the sensor position is specified or the borders can be extracted from it.

Keypoints[edit]

The pcl_keypoints library contains implementations of point cloud keypoint detection algorithms (AGAST corner point detector, Harris detector, BRISK detector, etc.).

Common[edit]

The pcl_common library contains the core data structures for point cloud, types for point representation, surface normals, RGB color values, etc. There are also implemented useful methods for computing distances, mean values and covariance, geometric transformations, and more. The common library is mainly used by other PCL modules.

References[edit]

  1. ^ a b B. Rusu, Radu (28 March 2011). "PointClouds.org: A new home for Point Cloud Library (PCL)". Willow Garage. Retrieved 26 November 2012.
  2. ^ a b "PCL 1.0!". PCL. 12 May 2011. Retrieved 24 May 2013.Archived 2020-01-06 at the Wayback Machine
  3. ^ "Release 1.14.1". Retrieved 4 May 2024.
  4. ^ "Releases · PointCloudLibrary/PCL". GitHub.
  5. ^ Holz, Dirk; Ichim, Alexandru E.; Tombari, Federico; Rusu, Radu B.; Behnke, Sven (2015). "Registration with the Point Cloud Library: A Modular Framework for Aligning in 3-D". IEEE Robotics Automation Magazine. 22 (4): 110–124. doi:10.1109/MRA.2015.2432331. S2CID 2621807.
  6. ^ Robot Operating System: http://www.ros.org/wiki
  7. ^ Hsieh, C. (2012). "An efficient development of 3D surface registration by Point Cloud Library (PCL)". 2012 International Symposium on Intelligent Signal Processing and Communications Systems. pp. 729–734. doi:10.1109/ISPACS.2012.6473587. ISBN 978-1-4673-5082-2. S2CID 5449026.
  8. ^ a b Rusu, R. B.; Cousins, S. (2011). "3D is here: Point Cloud Library (PCL)". 2011 IEEE International Conference on Robotics and Automation. pp. 1–4. doi:10.1109/ICRA.2011.5980567. ISBN 978-1-61284-386-5. S2CID 206849822.
  9. ^ "Google Summer of Code 2020". Point Cloud Library. Retrieved 2020-11-09.
  10. ^ "Building PCL's dependencies from source on Windows — Point Cloud Library 0.0 documentation". pcl.readthedocs.io. Retrieved 2020-11-02.
  11. ^ a b "The PCD (Point Cloud Data) file format — Point Cloud Library 0.0 documentation". pcl.readthedocs.io. Retrieved 2020-11-02.
  12. ^ "The PCD (Point Cloud Data) file format — Point Cloud Library 0.0 documentation".
  13. ^ "Point Cloud Library (PCL): pcl::PCDReader Class Reference". pointclouds.org. Retrieved 2020-11-02.
  14. ^ "PCL Walkthrough — Point Cloud Library 0.0 documentation". pcl.readthedocs.io. Retrieved 2020-11-03.
  15. ^ "Introduction — Point Cloud Library 0.0 documentation". pcl.readthedocs.io. Retrieved 2020-11-04.

External links[edit]

Retrieved from "https://en.wikipedia.org/w/index.php?title=Point_Cloud_Library&oldid=1224641199"