KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #developer-tools #ai-agent #claude-code #codex #typescript #ai-agents #deepseek-harness #mcp #cli #rust

pointelligence

★ 58 Open GitHub ↗

the official implementation of PointCNN++ (CVPR 2026)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Pointelligence

### 🚀 Accelerating Point Cloud Learning for Spatial Intelligence

[![arXiv](https://img.shields.io/badge/arXiv-2511.23227-b31b1b.svg)](https://arxiv.org/abs/2511.23227)
[![CVPR 2026](https://img.shields.io/badge/CVPR-2026-4b44ce.svg)](https://arxiv.org/abs/2511.23227)
[![GitHub](https://img.shields.io/badge/GitHub-Code-181717.svg?logo=github)](https://github.com/ant-research/pointelligence)

<p align="center">
  <a href="#-installation">Installation</a> •
  <a href="#-basic-usages">Usage</a> •
  <a href="#-citation">Citation</a> •
  <a href="#-core-concepts">Concepts</a>
</p>

</div>

---

## 📖 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++](https://arxiv.org/abs/2511.23227) (CVPR 2026) — a significant evolution of [PointCNN](https://github.com/yangyanli/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 |

---

## 🆕 v1.5.0 — Faster Convolution Geometry

`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](docs/sorted_grid_geometry.md).

---

## 📊 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:

<table>
<tr>
<td width="50%">
<p align="center">
<img src="assets/fig_D.jpeg" alt="Memory Usage Comparison" width="100%"/>
<br>
<b>Figure D.</b> Memory usage comparison of one convolution layer.
</p>
</td>
<td width="50%">
<p align="center">
<img src="assets/fig_F.jpeg" alt="Peak Memory Comparison" width="100%"/>
<br>
<b>Figure F.</b> Peak memory comparison of ResNet-18 backbones.
</p>
</td>
</tr>
</table>

### Speed Benchmarks

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

<table>
<tr>
<td width="50%">
<p align="center">
<img src="assets/fig_E.jpeg" alt="Performance Comparison" width="100%"/>
<br>
<b>Figure E.</b> Operator-level latency analysis.
</p>
</td>
<td width="50%">
<p align="center">
<img src="assets/fig_G.jpg" alt="Backbone Performance" width="100%"/>
<br>
<b>Figure G.</b> End-to-end ResNet-18 backbone performance.
</p>
</td>
</tr>
</table>

---

## 📥 Clone the Repository

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

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

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

```shell
git submodule update --init --recursive
```

The submodules pin **upstream-pristine** commits of [chrischoy/FCGF](https://github.com/chrischoy/FCGF) and [Pointcept/Pointcept](https://github.com/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/`:

```shell
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`](overlays/README.md) and [`docs/reproduction/00_setup_overlay.md`](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:

```shell
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:

```shell
# 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](#-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/`](docs/reproduction/README.md).

### Point Cloud Registration — FCGF

PointCNN++ serves as the backbone of a [Fully Convolutional Geometric Features](https://github.com/chrischoy/FCGF) 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](https://github.com/Pointcept/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](https://arxiv.org/abs/2511.23227)\
    [Lihan Li](https://lihhan.github.io/), Haofeng Zhong, Rui Bu, Mingchao Sun, [Wenzheng Chen](https://wenzhengchen.github.io/), [Baoquan Chen](https://baoquanchen.info/), [Yangyan Li](https://yangyan.li)
    ```text
    @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](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](docs/sorted_grid_geometry.md)

pointelligence

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README