Skip to content
Python bindings for the Point Cloud Library (PCL)
Python C++
Branch: master
Clone or download
Type Name Latest commit message Commit time
Failed to load latest commit information.
generators add more namespace level functions Aug 24, 2018
pclpy Add laz file extension to read() method Sep 24, 2018
.gitignore clean gitignore Apr 10, 2018
LICENSE small fixes Apr 13, 2018
requirements_dev.txt use unidecode instead of replacing individual characters Jun 18, 2018 update pclpy_dependencies version Jun 12, 2018

pclpy: PCL for python

PyPI PyPI Python version

Python bindings for the Point Cloud Library (PCL). Generated from headers using CppHeaderParser and pybind11.

This library is in active development, the api is likely to change. The included modules do work, but tests are incomplete, and corner cases are still common.

Only Windows and python 3.6 x64 are supported at the moment.

Contributions, issues, comments are welcome!

Github repository:



Many other python libraries tried to bind PCL. The most popular one being python-pcl, which uses Cython. While Cython is really powerful, binding C++ templates isn't one of its strenghts (and PCL uses templates heavily). The result for python-pcl is a lot of code repetition, which is hard to maintain and to add features to, and incomplete bindings of PCL's classes and point types.

Using pybind11, we use C++ directly. Templates, boost::smart_ptr and the buffer protocol are examples of things that are simpler to implement.

The results so far are very promising. A large percentage of PCL is covered.


Windows with python 3.6 x64

pip install pclpy

When pip installs the project, pclpy_dependencies is installed as a requirement. This simple package contains only the PCL dlls required on Windows so you don't have to download a PCL release or build it.


Not working for now. Contributions are welcome!


  • All point types are implemented (those specified by the default msvc compile flags)
  • You can view point cloud data as numpy arrays using cloud.x or
  • boost::shared_ptr is handled by pybind11 so it's completely abstracted at the python level
  • laspy integration for reading/writing las files


You can use either a high level, more pythonic api, or the wrapper over the PCL api. The wrapper is meant to be as close as possible to the original PCL C++ api.

Here is how you would use the library to process Moving Least Squares. See the PCL documentation:

Using the higher level api:

import pclpy

# read a las file
point_cloud ="street.las", "PointXYZRGBA")
# compute mls
output = point_cloud.moving_least_squares(search_radius=0.05, compute_normals=True, num_threads=8)

Or the wrapper over the PCL api:

import pclpy
from pclpy import pcl

point_cloud ="street.las", "PointXYZRGBA")
mls = pcl.surface.MovingLeastSquaresOMP.PointXYZRGBA_PointNormal()
tree =
output = pcl.PointCloud.PointNormal()

You can see the wrapper is very close to the C++ version:

// C++ version

pcl::PointCloud<pcl::PointXYZ>::Ptr point_cloud (new pcl::PointCloud<pcl::PointXYZ> ());
pcl::io::loadPCDFile ("bunny.pcd", *point_cloud);
pcl::MovingLeastSquaresOMP<pcl::PointXYZ, pcl::PointNormal> mls;
pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ>);
mls.setSearchRadius (0.05);
mls.setPolynomialFit (false);
mls.setNumberOfThreads (12);
mls.setInputCloud (point_cloud);
mls.setSearchMethod (tree);
mls.setComputeNormals (true);
pcl::PointCloud<pcl::PointNormal> output;
mls.process (output);


  • 2d
  • common
  • geometry
  • features
  • filters
  • io
  • kdtree
  • keypoints
  • octree
  • recognition
  • sample_consensus
  • search
  • segmentation
  • stereo
  • surface
  • tracking
  • visualization

These modules are skipped for now

  • ml
  • people
  • outofcore
  • registration
  • every module not in the PCL Windows release (gpu, cuda, etc.)

Not Implemented

(see github issues and the what to skip section in generators/

To build

Windows with python 3.6 x64

  • Download PCL release for Windows (PCL-1.8.1-AllInOne-msvc2017-win64.exe) at:
  • PCL_ROOT environment variable must be set to the installation directory of PCL
  • About requirements:
  • Generate modules using
  • There is a missing file from the PCL release that you should get from the github repo: 2d/impl/kernel.hpp
  • Must be built with x64 version of cl.exe because of the large memory usage (see workaround in
  • python install
  • Useful arguments:
    • --msvc-mp-build should enable a multiprocessed build
    • --msvc-no-code-link makes linking much faster (do not use for releases, see description)
    • --use-clcache to cache msvc builds using clcache (must be installed)
    • --debug to build in debug mode


  • Wrap as much of PCL as reasonably possible
  • More tests
  • CI on Appveyor
  • Make it work on Linux
You can’t perform that action at this time.