Point Cloud Registration

point-cloud-registration is a pure Python, lightweight, and fast point cloud registration library.
It outperforms PCL and Open3D's registration in speed while relying only on NumPy for computations.

Features

✅ Pure Python – No compiled extensions, works everywhere
✅ Fast & Lightweight – Optimized algorithms with minimal overhead
✅ NumPy-based API – Seamless integration with scientific computing workflows

The following registration algorithms are supported, with our pure Python point-cloud-registration being even faster than the C++ versions of PCL and Open3D (C++ & Python wrappers).

Current Support Algorithm and Speed Comparison ¹

Method	Our (sec)	Open3D (sec)	PCL (sec)
Point-to-Point ICP	0.502	1.511	0.931
Point-to-Plane ICP 2	0.334	0.677	0.835
Voxelized Point-to-Plane ICP	0.420	N/A	N/A
Normal Distributions Transform (NDT)	0.511	N/A	1.782
Normal Estimation	2.201	1.708	2.048

---

Installation

Install via pip:

pip install point-cloud-registration
pip install q3dviewer==1.1.6 # (optional) for visual demo

You can benchmark it yourself using the following commands:

cd benchmark
python3 speed_test_comparison.py # Compare our implementation with Open3D
python3 speed_test_comparison_mkl.py # (optional) you can further boost it by using mkl numpy
mkdir build && cd build
cmake .. && make
./speed_test_comparison # Compare with PCL

Usage

#!/usr/bin/env python3

import numpy as np
from point_cloud_registration import ICP, PlaneICP, NDT, VPlaneICP

# Example point clouds
target = np.random.rand(100, 3)  # Nx3 point numpy array
scan = np.random.rand(80, 3)    # Mx3 point numpy array

icp = VPlaneICP(voxel_size=0.5, max_iter=30, max_dist=2, tol=1e-3)
icp.set_target(target)  # Set the target point cloud
T_new = icp.align(scan, init_T=np.eye(4))  # Fit the scan to the target
print("Estimated Transform matrix:\n", T_new)

Roadmap

🚀 Upcoming Features & Enhancements:

• Point-to-Point ICP – Basic ICP implementation
• Point-to-Plane ICP – Improved accuracy using normal constraints
• Generalized ICP (GICP) – Handles anisotropic noise and improves robustness
• Normal Distributions Transform (NDT) – Grid-based registration for high-noise environments
• Further optimizations while staying pure Python

Demo

Explore the capabilities of the library with the following demos:

Visualize Estimated Normals

Quickly estimate and visualize normals using our fast Python implementation:

python3 demo_estimate_normals.py

Visualize Voxels

Visualize 3D voxelization with our efficient Python-based algorithm:

python3 demo_visualize_voxels.py

Try Point Cloud Registration

Explore our Cloud Registration algorithms using a sample GUI. You can experiment with different settings:

python3 demo_matching.py

Comparison of Registration Methods

Method	Objective Function*	Data Representation	Speed	Precision
Point-to-Point ICP	$\sum | T p_i - q_i |^2$	Point-Based	Fast	Moderate
Point-to-Plane ICP	$\sum | n_i^T (T p_i - q_i) |^2$	Point-Based (with normals)	Fast	High
Voxelized Point-to-Plane ICP	$\sum | n_i^T (T p_i - q_i) |^2$	Voxel-Based (with normals)	Very Fast	High
Generalized ICP (GICP)	$\sum (T p_i - q_i)^T (C_i^Q + R C_i^P R^T)^{-1} (T p_i - q_i)$	Point-Based (with covariances)	Moderate	Very High
Normal Distributions Transform (NDT)	$\sum (T p_i - \mu_i)^T \Sigma_i^{-1} (T p_i - \mu_i)$	Voxel-Based (with covariances)	Very Fast	Moderate

---

License

This project is licensed under the MIT License - see the LICENSE file for details.

Footnotes

1. Note: The above times are based on the test data in data/B-01.pcd with over 1,000,000 points, licensed under CC BY 4.0. For more information, see data/README.md. ↩

2. Without Normal Estimation ↩