Pointelligence

🚀 Accelerating Point Cloud Learning for Spatial Intelligence

Installation • Usage • Citation • Concepts

---

📖 About

Pointelligence is a high-performance library for 3D point cloud deep learning research. It provides efficient GPU-accelerated primitives and ready-to-use neural network architectures for spatial intelligence tasks.

✨ Highlights

Feature	Description
🎯 PointCNN++	Official implementation of PointCNN++ (CVPR 2026) — a significant evolution of PointCNN (NeurIPS 2018)
⚡ High Performance	Optimized CUDA kernels for native point convolution with minimal memory overhead
📦 Ragged Tensors	Efficient batching without padding — process only valid data
🔧 Modular Design	Build custom architectures from composable primitives
🐳 Docker Ready	One-command setup with pre-built CUDA extensions

---

📊 Performance

PointCNN++ delivers state-of-the-art performance with significantly lower memory usage and faster training times compared to existing methods.

Memory Efficiency

Our native point-based approach fundamentally avoids the overhead of voxel-based auxiliary data structures:

Figure D. Memory usage comparison of one convolution layer.

Figure F. Peak memory comparison of ResNet-18 backbones.

Speed Benchmarks

Our custom Triton kernels (MVMR for forward, VVOR for backward) provide exceptional speed in both inference and training:

Figure E. Operator-level latency analysis.

Figure G. End-to-end ResNet-18 backbone performance.

---

📥 Clone the Repository

Clone the repository together with its third-party submodules (FCGF and Pointcept):

git clone --recursive https://github.com/ant-research/pointelligence.git
cd pointelligence

If you already cloned without --recursive, fetch the submodules with:

git submodule update --init --recursive

The submodules pin upstream-pristine commits of chrischoy/FCGF and Pointcept/Pointcept — they are never edited in place. PointCNN++-specific adaptations live under overlays/ and are applied out-of-tree by each submodule's build.sh, which writes a ready-to-use copy under build/:

bash overlays/FCGF/build.sh
bash overlays/Pointcept/build.sh

This keeps examples/FCGF and examples/Pointcept 100% pristine; the build step is idempotent (re-running rebuilds in seconds). See overlays/README.md and docs/reproduction/00_setup_overlay.md for how the overlay system works.

🛠️ Installation

Option 1: Local Installation

Some operators are implemented in C++/CUDA as PyTorch extensions; build and install them with:

conda create -n pointelligence python=3.10 -y
conda activate pointelligence
pip install -r requirements.txt
cd extensions
pip install --no-build-isolation -e .

Option 2: Docker Installation

Use Docker for a containerized environment with all dependencies pre-installed:

# Build the Docker image
docker build -t pointelligence .

# Test the containerized environment
docker run --gpus all -it -v $(pwd):/workspace pointelligence

# Verify installation
python -m pytest tests/unittest/ -v

The Docker image includes:

• CUDA 12.6 + cuDNN + PyTorch 2.6.0+ with GPU support
• Pre-built CUDA extensions (sparse_engines_cuda)
• All system dependencies and Python packages
• Sample data preloaded
• Ready-to-use development environment

💡 Basic Usages

Both example pipelines run against the overlay-built submodule trees, so run bash overlays/FCGF/build.sh and bash overlays/Pointcept/build.sh first (see Clone the Repository above) — the overlay build is what injects PointCNN++ into the otherwise-pristine upstream code, producing ready-to-run copies under build/.

For complete, copy-pasteable train → evaluate commands, follow the reproduction guide: docs/reproduction/.

Point Cloud Registration — FCGF

PointCNN++ serves as the backbone of a Fully Convolutional Geometric Features registration pipeline — it learns per-point descriptors that match corresponding points across two overlapping scans. The reproduction guide covers the 3DMatch (RGB-D) and KITTI (LiDAR) registration benchmarks end to end.

Point Cloud Segmentation — Pointcept

PointCNN++ plugs into the Pointcept framework as a semantic-segmentation backbone, trained with Pointcept's standard tools/train.py driver and a PointCNN++ model config. The reproduction guide covers self-supervised pretraining and NuScenes semantic-segmentation fine-tuning.

📚 Citation

Pointelligence is the repo for the official implementation of:

• PointCNN++: Performant Convolution on Native Points
  Lihan Li, Haofeng Zhong, Rui Bu, Mingchao Sun, Wenzheng Chen, Baoquan Chen, Yangyan Li

  @misc{li2025pointcnnperformantconvolutionnative,
        title={PointCNN++: Performant Convolution on Native Points}, 
        author={Lihan Li and Haofeng Zhong and Rui Bu and Mingchao Sun and Wenzheng Chen and Baoquan Chen and Yangyan Li},
        year={2025},
        eprint={2511.23227},
        archivePrefix={arXiv},
        primaryClass={cs.CV},
        url={https://arxiv.org/abs/2511.23227}, 
  }
  

🐛 Feature Requests and Issues

To ensure they are tracked effectively, please submit feature requests and issue reports here rather than via email.

🔬 Core Concepts

For building custom architectures, see docs/ADVANCED.md covering:

• Ragged tensors — efficient batching without padding
• Neighborhoods — fixed-radius search producing (i, j) pairs
• Convolution triplets — extending (i, j) to (i, j, k) to route data through kernel weights
• MVMR — the sparse convolution operator: output[i] += weight[k] @ input[j]