Pointelligence

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.

v1.5.0 accelerates the geometry work around PointConv3d while preserving exact fixed-radius neighbor sets and convolution-triplet semantics:

• exact sorted-grid radius search is now the production auto backend;
• radius search can emit kernel-tap segments directly, avoiding a separate global triplet sort;
• center-nearest grid downsampling uses a compact segmented GPU selector;
• conv_with_stride_full_cover adds an opt-in overlapping strided convolution whose centers are observed input points and whose input coverage is guaranteed by construction.

Against the exact public v1.4.0 implementations on identical transformed ScanNet workloads, correctness-gated real-data benchmarks measured a 2.179x geometric-mean radius-search speedup with 76.0% lower geometric-mean incremental peak allocation, and a 1.827x geometric-mean center-nearest downsampling speedup with 27.1% lower peak allocation (16 cells each, RTX 5880 Ada). Direct tap-segmented triplet preparation independently measured a 1.301x geometric-mean speedup across six indoor/outdoor cells. These are geometry-stage measurements rather than whole-network speedups. See the exact v1.4.0 comparison, H200 backend-selection study, memory tables, caveats, and reproduction commands in Sorted-Grid Convolution Geometry.

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

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

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

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.

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 .

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

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/.

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.

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.

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}, 
  }
  

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

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]
• Sorted-grid geometry — exact radius search, tap-segmented triplets, full-cover strided convolution, and center-nearest downsampling in v1.5.0