TurboReg: A Game-Changer for Point Cloud Registration

Introduction

In the digital age, accurate and efficient point cloud registration has become crucial across various industries, from autonomous driving to virtual reality. However, traditional point cloud registration methods often struggle with slow processing speeds and low efficiency, especially when dealing with large-scale data. To address these challenges, researchers have developed TurboReg, a highly efficient and robust estimator for point cloud registration (PCR) that delivers state-of-the-art performance while maintaining remarkable speed.

What is TurboReg?

TurboReg is a cutting-edge solution for point cloud registration, designed to align 3D scans from different viewpoints of the same scene. It is particularly valuable for tasks like simultaneous localization and mapping (SLAM) and virtual reality. The core innovation of TurboReg lies in its use of a novel lightweight clique called TurboClique and a highly parallelizable Pivot-Guided Search (PGS) algorithm.

The Core Technology Behind TurboReg

TurboClique: A Lightweight and Stable Clique Structure

TurboClique is a 3-clique within a highly-constrained compatibility graph. This lightweight nature allows for efficient parallel searching, while the rigorous compatibility constraints ensure stable spatial consistency for reliable transformation estimation.

Pivot-Guided Search (PGS) Algorithm: Efficient and Effective Search

The PGS algorithm selects matching pairs with high SC² scores as pivots, guiding the search toward TurboCliques with higher inlier ratios. With linear time complexity, PGS is significantly more efficient than the maximal clique search with exponential time complexity.

TurboReg’s Workflow

TurboReg takes correspondences as input and constructs an Ordered SC² Graph (O2Graph). The PGS algorithm is then applied to the O2Graph to produce TurboCliques. Finally, during the model estimation step, a transformation is estimated for each TurboClique, and the highest-scoring transformation is selected to align the source and target point clouds.

Advantages of TurboReg

Outstanding Performance

Extensive experiments have demonstrated that TurboReg achieves state-of-the-art performance across multiple real-world datasets. For instance, on the 3DMatch+FCGF dataset, TurboReg (1K) operates 208.22× faster than 3DMAC while achieving higher recall.

Speed and Efficiency

TurboReg’s highly parallelizable design and linear time complexity make it exceptionally fast. It can process large-scale point cloud data in real-time, making it suitable for time-sensitive applications.

Learning-Free and Parameter-Friendly

TurboReg does not rely on deep learning, eliminating the need for extensive training. Its parameter-friendly design makes it easy to use and adapt to different scenarios.

Getting Started with TurboReg

Installation

Python API

1. Clone the TurboReg repository from GitHub.

git clone https://github.com/Laka-3DV/TurboReg.git
cd TurboReg

  2. Create a Python virtual environment and activate it.
     ```bash
conda create -n turboreg python=3.11
conda activate turboreg

3. Install the required packages.

pip install open3d tyro

Install PyTorch (select the appropriate version for your CUDA setup from https://pytorch.org/)

pip3 install torch torchvision torchaudio –index-url https://download.pytorch.org/whl/cu118

  4. Install TurboReg.
     ```bash
cd bindings
pip install .
cd ..

C++ Build Instructions

1. Install the dependencies: CMake ≥ 3.10 and LibTorch.
2. Build TurboReg.

mkdir build_ && cd build_
cmake .. -DCMAKE_PREFIX_PATH=python -c "import torch; print(torch.utils.cmake_prefix_path)"
make -j8

  3. Run the C++ demo.
     ```bash
./demo_cpp/demo_corr_fpfh

Code Example

Here’s a simple Python example to get you started:

import numpy as np
import torch
import turboreg_gpu  # NOTE: torch must be imported before turboreg_gpu

# Load input correspondences
kpts_src = torch.from_numpy(np.loadtxt('demo_data/000_fpfh_kpts_src.txt')).cuda().float()
kpts_dst = torch.from_numpy(np.loadtxt('demo_data/000_fpfh_kpts_dst.txt')).cuda().float()

# Initialize TurboReg
reger = turboreg_gpu.TurboRegGPU(
    6000,      # max_N: Maximum number of correspondences
    0.012,     # tau_length_consis: \tau (consistency threshold for feature length/distance)
    2000,      # num_pivot: Number of pivot points, K_1
    0.15,      # radiu_nms: Radius for avoiding the instability of the solution
    0.1,       # tau_inlier: Threshold for inlier points. NOTE: just for post-refinement (REF@PointDSC/SC2PCR/MAC)
    "IN"       # eval_metric: MetricType (e.g., "IN" for Inlier Number, or "MAE" / "MSE")
)

# Run registration
trans = reger.run_reg(kpts_src, kpts_dst)

Experiment Reproduction

Download the processed 3DMatch correspondences from MAC++. Organize the folder structure as follows:

DIR_3DMATCH_FPFH_FCGF
.
├── 3DMatch
│   ├── all_fcgf
│       ├── 7-scenes-redkitchen
│       └── ...
│   └── all_fpfh
│       ├── 7-scenes-redkitchen
│       └── ...

Run the following script:

# For 3DMatch + FPFH
python -m demo_py.exp_3dmatch --desc fpfh --dataname 3DMatch --dir_dataset "DIR_3DMATCH_FPFH_FCGF" --max_N 7000 --tau_length_consis 0.012 --num_pivot 2000 --radiu_nms 0.15 --tau_inlier 0.1 --metric_str "IN"

# For 3DMatch + FCGF
python -m demo_py.exp_3dmatch --desc fcgf --dataname 3DMatch --dir_dataset "DIR_3DMATCH_FPFH_FCGF" --max_N 6000 --tau_length_consis 0.012 --num_pivot 2000 --radiu_nms 0.10 --tau_inlier 0.1 --metric_str "MAE"

TurboReg’s Performance on Various Datasets

TurboReg has been rigorously tested on multiple datasets, including 3DMatch, 3DLoMatch, and KITTI. It has achieved remarkable results in terms of registration recall (RR), rotation error (RE), translation error (TE), and frames per second (FPS).

FAQ

What Problem Does TurboReg Solve?

TurboReg addresses the challenges of slow speed and low efficiency in traditional point cloud registration methods. It provides a fast and robust solution for aligning 3D scans from different viewpoints.

How Does TurboReg Compare to Other Methods?

Compared to traditional methods, TurboReg offers faster processing speeds and higher robustness. It can handle large-scale data efficiently while maintaining high accuracy.

On Which Platforms Can TurboReg Run?

TurboReg supports both CPU and GPU platforms. Users can choose the appropriate platform based on their specific needs.

How to Install and Use TurboReg?

TurboReg can be installed and used easily by following the official documentation. It provides both Python API and C++ build instructions.

What is TurboReg’s Performance Like?

TurboReg has demonstrated excellent performance across multiple datasets. It achieves high registration recall and fast processing speeds.

Conclusion

TurboReg represents a significant advancement in the field of point cloud registration. With its innovative TurboClique structure and efficient PGS algorithm, it offers a powerful tool for researchers and engineers to quickly and accurately align 3D scanning data in complex scenarios. As technology continues to evolve, TurboReg is expected to play a more important role in various applications.

Acknowledgements

TurboReg builds upon several excellent open-source works:

• XuyangBai/PointDSC
• ZhiChen902/SC2-PCR
• zhangxy0517/3D-Registration-with-Maximal-Cliques

If you find TurboReg useful for your work or project, please consider citing the following paper:

@misc{yan2025turboregturbocliquerobustefficient,
      title={TurboReg: TurboClique for Robust and Efficient Point Cloud Registration}, 
      author={Shaocheng Yan and Pengcheng Shi and Zhenjun Zhao and Kaixin Wang and Kuang Cao and Ji Wu and Jiayuan Li},
      year={2025},
      eprint={2507.01439},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2507.01439}, 
}