🔥 RAPiD-Seg: Range-Aware Pointwise Distance Distribution Networks for 3D LiDAR Segmentation [ECCV 2024 Oral]

A PyTorch implementation of the RAPiD feature extraction algorithm for 3D point cloud processing. RAPiD (Range-Aware Point cloud Descriptor) combines geometric and reflectivity information to create robust features for LiDAR-based 3D object detection.

Updates

• [2024.08] RAPiD was selected as an ✨ Oral ✨ at ECCV 2024.
• [2024.07] Our paper is available on arXiv, click here to check it out. The code will be available later.

🚀 Features

• 4D Distance Computation: Combines geometric and reflectivity components for comprehensive feature representation
• Range-Aware Processing: Adaptive feature extraction based on point cloud density and range
• KITTI Format Support: Native support for KITTI dataset point cloud data
• GPU Acceleration: Full CUDA support for high-performance processing
• Comprehensive Testing: Extensive test suite with high coverage
• Easy Integration: Simple API for seamless integration into existing projects

📦 Installation

From Source

# Clone the repository
git clone https://github.com/l1997i/rapid-seg.git
cd rapid-seg

# Install with pip
pip install -e .

# Or install with uv (faster)
uv pip install -e .

Development Installation

# Clone and install with development dependencies
git clone https://github.com/l1997i/rapid-seg.git
cd rapid-seg

# Install with all development tools
pip install -e ".[dev,all]"

# Or with uv
uv pip install -e ".[dev,all]"

🎯 Quick Start

import torch
from rapid_seg import RAPiDCalculator, PointCloudLoader
from rapid_seg.config import create_config

# Create sample point cloud data
n_points = 1000
coordinates = torch.randn(n_points, 3) * 10.0  # 3D coordinates
reflectivity = torch.rand(n_points) * 0.8 + 0.1  # Reflectivity values

# Initialize RAPiD calculator
config = create_config("balanced", k_mid=8)
calculator = RAPiDCalculator(device=config.device)

# Compute RAPiD features
k = config.get_k_for_standard_rapid()
rapid_features = calculator.compute_rapid_features(
    coordinates, reflectivity, k
)

print(f"RAPiD features shape: {rapid_features.shape}")
print(f"Features range: [{rapid_features.min():.3f}, {rapid_features.max():.3f}]")

📚 Usage Examples

Basic Feature Extraction

from rapid_seg import RAPiDCalculator, PointCloudLoader

# Load point cloud data
loader = PointCloudLoader()
coordinates, reflectivity = loader.load_and_preprocess("data.bin")

# Create RAPiD calculator
calculator = RAPiDCalculator(device="cuda" if torch.cuda.is_available() else "cpu")

# Compute standard RAPiD features
rapid_features = calculator.compute_rapid_features(
    coordinates, reflectivity, k=10
)

Range-Aware Processing

# Compute range-aware RAPiD features
range_aware_features = calculator.compute_range_aware_rapid(
    coordinates, reflectivity, 
    k_close=3,    # Close range: high density
    k_mid=5,      # Mid range: balanced
    k_far=2       # Far range: low density
)

Configuration Management

from rapid_seg.config import create_config, RAPiDConfig

# Use predefined configurations
config = create_config("balanced")      # Balanced performance
config = create_config("fast")          # Fast processing
config = create_config("accurate")      # High accuracy

# Custom configuration
custom_config = RAPiDConfig(
    k_mid=12,
    device="cuda",
    batch_size=64
)

🔧 Configuration Options

Parameter	Description	Default	Options
k_mid	Number of neighbors for mid-range	8	4-16
device	Processing device	"auto"	"cpu", "cuda"
batch_size	Batch size for processing	32	16-128
precision	Floating point precision	"float32"	"float16", "float32"

📊 Performance

RAPiD is optimized for high-performance point cloud processing:

• Speed: Up to 10x faster than traditional methods
• Memory: Efficient memory usage with batch processing
• Accuracy: State-of-the-art feature quality
• Scalability: Handles point clouds with 100K+ points

🧪 Testing

# Run all tests
pytest rapid_seg/tests/ -v

# Run with coverage
pytest rapid_seg/tests/ --cov=rapid_seg --cov-report=html

# Run specific test categories
pytest rapid_seg/tests/test_core.py -v
pytest rapid_seg/tests/test_features.py -v

📖 Documentation

• API Reference
• Examples

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Setup

# Clone and setup development environment
git clone https://github.com/l1997i/rapid-seg.git
cd rapid-seg

# Install development dependencies
pip install -e ".[dev]"

# Run pre-commit hooks
pre-commit install

# Run tests
pytest rapid_seg/tests/ -v

📄 License

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

Citation

If you are making use of this work in any way, you must please reference the following paper in any report, publication, presentation, software release or any other associated materials:

RAPiD-Seg: Range-Aware Pointwise Distance Distribution Networks for 3D LiDAR Segmentation (Li Li, Hubert P. H. Shum and Toby P. Breckon), In Proc. Eur. Conf. Comput. Vis. (ECCV), 2024. [homepage] [pdf] [video] [poster]

@inproceedings{li2024rapidseg,
  title = {{{RAPiD-Seg}}: {{Range-Aware}} {{Pointwise Distance Distribution}} {{Networks}} for {{3D LiDAR Segmentation}}},
  author = {Li, Li and Shum, Hubert P. H. and Breckon, Toby P.},
  keywords = {point cloud, semantic segmentation, invariance feature, pointwise distance distribution, autonomous driving},
  year = {2024},
  month = jul,
  publisher = {{Springer}},
  booktitle = {European Conference on Computer Vision (ECCV)},
}