RadiusFPS: Efficient Farthest Point Sampling on CPUs and GPUs via Spherical Voxel Pruning

Abstract: Point clouds are a primary sensory representation for robotic perception, underpinning LiDAR-based autonomous driving, simultaneous localization and mapping (SLAM), and navigation. Within these pipelines, Farthest Point Sampling (FPS) is the most well-known downsampling operator, as its uniform coverage preserves the geometric structure on which downstream perception relies. However, the large time complexity of classical FPS scales poorly with the million-point-per-second rates of modern 3D sensors, making it a dominant latency bottleneck that conflicts with the real-time and limited onboard compute budgets of robotic systems. Therefore, we propose RadiusFPS, an FPS acceleration framework based on spherical voxel pruning that preserves the standard FPS update rule under the same initialization and tie-breaking policy. By indexing the point cloud with spherical voxels, RadiusFPS derives a conservative geometric bound that prunes redundant distance computations in each iteration, complemented by a coordinate-wise point-skip test that removes residual updates. We further introduce RadiusFPS-G, a warp-level GPU implementation that fuses voxel selection, pruning, and distance update into memory-coalesced kernels, eliminating costly global-memory round-trips. On indoor (S3DIS, ScanNet) and outdoor LiDAR (SemanticKITTI) benchmarks, RadiusFPS-G attains up to 2.5x speedup over GPU-based FPS and matches or exceeds QuickFPS among the evaluated methods while using roughly half its GPU memory, with comparable segmentation accuracy. When coupled with the learning-based FastPoint sampler, the resulting pipeline achieves the fastest End-to-End inference among all evaluated configurations. These properties make high-quality FPS-style sampling practical for latency- and memory-constrained robotic vision.

• The paper introduces RadiusFPS, which employs spherical voxel pruning to precisely accelerate farthest point sampling for dense point clouds.
• The method’s hierarchical filtering and custom GPU kernel fusion achieve up to 52.4× and 186.5× speedups on GPU and CPU, respectively, without compromising segmentation quality.
• The approach reduces redundant distance computations by over 90%, significantly decreasing inference latency and memory usage in real-time perception systems.

RadiusFPS: Exact Farthest Point Sampling Acceleration via Spherical Voxel Pruning

Introduction

Efficient and high-quality downsampling of large-scale point clouds is a critical requirement in robotics and autonomous systems, particularly due to the increased throughput of modern LiDAR sensors. Farthest Point Sampling (FPS) is the canonical algorithm for ensuring uniform coverage while preserving geometric structure, and it serves as an essential pre-processing step in tasks such as segmentation, object detection, and SLAM. However, the $O(NM)$ time complexity of classical FPS renders it a substantial bottleneck in real-time applications and memory-constrained environments, especially for dense scenes containing hundreds of thousands to millions of points.

To resolve these limitations while retaining the exact FPS sampling pattern, this work introduces RadiusFPS, an acceleration strategy based on spherical voxel pruning, alongside RadiusFPS-G, a GPU-centric fused-kernel architecture. The approach strategically eliminates ineffective computations without violating the algorithm’s exactness, yielding significant speedups on both CPU and GPU and reducing latency in end-to-end perception pipelines.

Figure 1: Efficiency analysis of FPS on S3DIS and ScanNet; sampling latency explodes for large point clouds as FPS becomes the major bottleneck in state-of-the-art networks.

Methodology

Spherical Voxel Pruning and Hierarchical Filtering

RadiusFPS decomposes the FPS update into a hierarchical pruning process. First, the input is partitioned into active voxels, and both point-level ($Dist_p$) and voxel-level ($Dist_v$) nearest-sample distance arrays are maintained. Instead of traversing all points at each iteration, the algorithm:

1. Selects the next farthest sample via a two-level argmax: first, the voxel with the largest $Dist_v$, then the farthest point within that voxel.
2. Applies radius-based spherical voxel pruning: for a given newly selected sample, a lower-bound on distance to every point in a voxel is computed as $||s_j - c_k||_2 - r_k$, where $c_k$ is the voxel center and $r_k$ its inscribed radius. If this lower bound exceeds the maximum stored distance in that voxel, the entire voxel is skipped.
3. Applies a coordinate-wise point skip: for remaining candidate points, if any axis-aligned (L-infinity) coordinate difference between the new sample and point exceeds the current nearest distance, the point is skipped as it cannot yield an improvement.

This coarse-to-fine filtering drastically reduces redundant distance computations, as most iterations in classical FPS yield over 90% ineffective updates.

Figure 2: Sampling uniformity comparison; FPS produces homogeneous coverage unlike random sampling, as evidenced by tighter nearest neighbor statistics.

Figure 3: Algorithmic overview illustrating the three-stage pipeline: voxelization, distance initialization, and iterative sampling with hierarchical pruning.

GPU Implementation with Kernel Fusion

RadiusFPS-G integrates the computation into two custom CUDA kernels:

• Fusion Kernel 1 implements the two-level reduction (max-voxel, max-point) via warp-synchronous reductions, ensuring deterministic selection and efficient memory access.

  Figure 4: Fusion Kernel 1 combines voxel and point reductions, minimizing kernel launch and memory costs.

• Fusion Kernel 2 maps each active voxel to an independent CUDA block, performing both voxel-level filtering and parallel distance updates, again relying on shared memory and coordinated block-level reductions for efficiency.

  Figure 5: Two-stage warp-level reduction within a CUDA block minimizes synchronization and exploits intra-warp parallelism.

These fusions eliminate high-frequency kernel launch overhead, minimize global memory traffic, and fit the hierarchical update logic of RadiusFPS into parallel hardware. The voxelization and buffer reordering ensures coalesced memory access, crucial under the massively parallel GPU model.

Experimental Results

Throughput, Latency, and Segmentation Quality

Rigorous benchmarks on S3DIS, ScanNet, and SemanticKITTI using PointMetaBase and PointVector architectures demonstrate that RadiusFPS-G achieves up to 52.4$\times$ speedup on GPU and 186.5$\times$ on CPU relative to classical FPS, with memory usage roughly half that of the KD-tree-based QuickFPS. In end-to-end network evaluation, the speedup in the sampling stage translates to a 2.5$\times$ reduction in total inference latency, further increased to over 3.3$Dist_p$0 when integrated with FastPoint learning-based heuristics.

Critically, segmentation quality is fully preserved: mIoU and OA metrics for both RadiusFPS and RadiusFPS-G remain indistinguishable (within 0.1-0.5%) from vanilla FPS, and exceed those of random, grid, or Morton code-based alternatives. The approach outperforms all approximate heuristic accelerators that compromise the exact sampling pattern.

Figure 6: Comprehensive runtime and speedup analysis; RadiusFPS-G and its FastPoint hybrid produce maximal acceleration across S3DIS, ScanNet, and SemanticKITTI in both backbones, where blue bars are total runtime and red are dedicated sampling time.

Visual and Structural Consistency

Qualitative and local analyses confirm that the geometric preservation and uniformity of downsampling are not disturbed by the acceleration strategies:

Figure 7: Close-up geometric detail comparison; RadiusFPS(-G) uniformly retains fine-grained features and spatial consistency at par with standard FPS.

Scalability and Parameter Sensitivity

Scalability analysis across varying scene sizes demonstrates robust throughput and memory efficiency. The only parameter of significance, the voxel grid resolution $Dist_p$1, exhibits insensitivity on GPU (due to parallel kernel design), but benefits from mild tuning (e.g., $Dist_p$2) on CPU for optimal cache efficiency.

Figure 8: Sampling speedup as function of voxel resolution $Dist_p$3; optimal setting yields peak speedups without incurring overhead from excessive granularity.

Implications and Future Directions

RadiusFPS closes the gap between the theoretical optimality of FPS and practical latency constraints in robotic perception and large-scale 3D deep learning. By preserving the exact update rule, it ensures downstream model quality is unaffected, avoiding the trade-offs of prior heuristics or learning-based approximations. Its efficiency makes exact FPS deployable on embedded and real-time systems, and its hybridization with learning-based samplers (FastPoint) demonstrates compatibility with predictive methods.

The theoretical conservativeness of spherical voxel pruning may be leveraged for further generalization, possibly in other nearest-neighbor or clustering-based sampling protocols. The GPU kernel fusion strategies are broadly applicable to hierarchical filtering workloads beyond FPS. However, further research could exploit adaptive multi-resolution voxelization or incorporate data-dependent partitioning for heterogeneous scenes, as well as extend the framework to support dynamic, streaming, or non-uniform density point cloud scenarios.

Conclusion

RadiusFPS and its GPU-specialized RadiusFPS-G variant constitute a principled and practically efficient solution for exact farthest point sampling in dense point cloud processing. By introducing provably safe spherical voxel pruning and optimized parallel reductions, the method achieves strong acceleration without sacrificing segmentation quality or sampling uniformity. Its integration into state-of-the-art perception backbones and compatibility with learning-based samplers suggest high utility for real-world robotic and autonomous systems that require robust, efficient geometric sampling.