RadiusFPS: Dual Approaches in Robotics and Graphics

• RadiusFPS is a dual-use term describing an exact acceleration of farthest point sampling in robotic 3D perception via spherical voxel pruning and a retinal-based frame-rate mapping in foveated graphics.
• In robotics, RadiusFPS accelerates point cloud sampling with voxel-level pruning and coordinate skip tests, leading to significant speedups while preserving exact FPS output.
• In foveated graphics, it computes a radius-to-frame-rate mapping derived from an eccentricity-dependent flicker fusion model, optimizing rendering for gaze-contingent displays.

RadiusFPS denotes two distinct constructs in recent arXiv literature. In robotic 3D perception, it is the name of an exact acceleration framework for Farthest Point Sampling (FPS) based on spherical voxel pruning, with CPU and GPU realizations designed for latency- and memory-constrained point-cloud pipelines (Yu et al., 4 Jun 2026). In foveated graphics, the same label appears as a shorthand for a radius-to-frame-rate map derived from an eccentricity-dependent critical flicker fusion (CFF) model, used to choose a maximal imperceptible update rate as a function of retinal radius (Krajancich et al., 2021). The shared term therefore does not identify a single unified method; it names two unrelated techniques in separate subfields.

1. Nomenclature and scope

The 2026 usage is algorithmic and geometric. Given a point cloud $P=\{p_0,\dots,p_{N-1}\}\subset\mathbb{R}^3$ and a desired sample size $M$, classical FPS iteratively maintains the distance array $D[i]$, updates it against the most recently selected sample, and chooses the next sample by a global $\arg\max$ over $D$. RadiusFPS preserves this standard FPS update rule under the same seed and tie-breaking policy, but accelerates the loop by pruning redundant distance computations through spherical voxel bounds and a coordinate-wise point-skip test (Yu et al., 4 Jun 2026).

The 2021 usage is perceptual and spatio-temporal. There, “RadiusFPS” is not presented as a standalone sampling algorithm; it is the step-by-step computation of a per-radius allowed frame-rate budget from the model $CFF(f,e,L)$, where $f$ is spatial frequency, $e$ is eccentricity, and $L$ is display luminance. The goal is to choose, for each retinal radius $r$, a maximal frame rate no greater than the CFF for the highest spatial-frequency content present at that radius (Krajancich et al., 2021).

A common source of confusion is the acronym “FPS” itself. In the robotic-vision literature it denotes Farthest Point Sampling; in the foveated-graphics setting it denotes frames per second. The two RadiusFPS usages are therefore homonymous rather than methodologically connected.

2. RadiusFPS as exact acceleration of Farthest Point Sampling

In the robotic-vision formulation, classical FPS is motivated by its near-uniform coverage and its role in protecting geometric structure for downstream tasks such as LiDAR-based autonomous driving, SLAM, navigation, and segmentation. Its computational bottleneck is the $M$0 distance-update loop: each of the $M$1 iterations updates distances to all $M$2 points, which becomes dominant when modern sensors produce up to millions of points per second and $M$3 exceeds $M$4–$M$5 (Yu et al., 4 Jun 2026).

RadiusFPS addresses this bottleneck by indexing the point cloud with active voxels. The axis-aligned bounding box of $M$6 is partitioned into cubic bins of side length

$M$7

where $M$8, and similarly for the other axes. For each active voxel $M$9, the method stores its centroid $D[i]$0, its minimal enclosing-sphere radius $D[i]$1, the set of point indices $D[i]$2, and the voxel-level maximum distance

$D[i]$3

The core FPS state remains

$D[i]$4

with the usual loop

$D[i]$5

The distinctive contribution is the conservative voxel-level pruning bound. For any $D[i]$6 and newly selected sample $D[i]$7,

$D[i]$8

Defining

$D[i]$9

RadiusFPS prunes the entire voxel whenever

$\arg\max$0

Under that condition, no point in $\arg\max$1 can improve its stored nearest-sample distance, so the per-point Euclidean update is unnecessary (Yu et al., 4 Jun 2026).

Within non-pruned voxels, RadiusFPS applies a second filter: $\arg\max$2 If

$\arg\max$3

then the Euclidean update is skipped for that point as well. Only the residual points require exact distance computation. This two-stage design is the basis for the reported average-case reduction from the full $\arg\max$4 work pattern, while worst-case complexity remains $\arg\max$5 when pruning fails (Yu et al., 4 Jun 2026).

3. Data structures, CPU realization, and GPU fusion kernels

The CPU formulation stores the points $\arg\max$6, the distance array $\arg\max$7, and an active voxel list $\arg\max$8, where each voxel keeps its point-index list $\arg\max$9, center $D$0, radius $D$1, and voxel-distance $D$2. The loop first builds active voxels by hashing each $D$3, initializes all $D$4 to $D$5, picks a random seed $D$6, computes initial distances, and initializes $D$7 by a per-voxel maximum over $D$8. Each subsequent iteration chooses the best voxel $D$9, the best point inside that voxel, adds the new sample, and then performs voxel-level pruning followed by point-level skip tests before recomputing the affected $CFF(f,e,L)$0 values (Yu et al., 4 Jun 2026).

The GPU realization, RadiusFPS-G, keeps the entire pipeline on the GPU to avoid host–device synchronization. Preprocessing assigns a 1D voxel ID to each point, performs a parallel radix-sort by voxel ID so that each voxel’s points are contiguous, gathers them into SoA format for coalesced access, and computes per-voxel offsets and counts. Initialization then selects the seed $CFF(f,e,L)$1, launches a branchless kernel to compute $CFF(f,e,L)$2, and performs parallel reductions to set $CFF(f,e,L)$3 (Yu et al., 4 Jun 2026).

Two fusion kernels organize the main loop. The first performs a two-level reduction: a warp-level reduction over $CFF(f,e,L)$4 identifies the best voxel $CFF(f,e,L)$5, then a block-level reduction over the points in $CFF(f,e,L)$6 identifies the best point $CFF(f,e,L)$7. The second maps one CUDA block to one active voxel, loads the new sample and voxel parameters into shared memory, computes the lower bound $CFF(f,e,L)$8, exits early if the voxel is pruned, otherwise applies the coordinate-skip test and Euclidean update to the assigned points, and finally reduces within the block to refresh $CFF(f,e,L)$9. The paper characterizes these kernels as fusing voxel selection, pruning, and distance update into memory-coalesced kernels and eliminating costly global-memory round-trips (Yu et al., 4 Jun 2026).

The theoretical guarantee is exactness rather than approximation. RadiusFPS preserves exact FPS output under the same seed and tie-breaking, and floating-point computations use the same precision and deterministic tie-breaking to guarantee reproducibility with classical FPS. This is significant because many FPS accelerations alter the selected subset; RadiusFPS is explicitly framed as a provably exact acceleration of the standard loop (Yu et al., 4 Jun 2026).

4. Empirical behavior, scaling, and operating regime

The 2026 evaluation uses S3DIS, ScanNet, and SemanticKITTI, with an Intel i7-12700KF CPU and an NVIDIA RTX 6000 Ada GPU. The reported metrics are sampling latency, end-to-end segmentation runtime, GPU memory, and segmentation accuracy measured by OA and mIoU. Baselines include CPU-FPS, GPU-FPS, QuickFPS, FPS+NPDU, and FastPoint (Yu et al., 4 Jun 2026).

The main reported outcomes are summarized below.

Setting	Reported result	Context
CPU	up to 186× speedup over vanilla CPU-FPS	large scenes
GPU	up to 52× reduction in sampling time vs. GPU-FPS	RadiusFPS-G
Memory	$f$0 of QuickFPS GPU memory footprint	latency matches or outperforms QuickFPS
S3DIS	40.18 s $f$1 15.34 s, mIoU 67.9% $f$2 68.3%	PointMetaBase / full validation
SemanticKITTI	1734 s $f$3 691 s, 49.72% $f$4 49.26%	negligible accuracy loss
With FastPoint	sampling up to 11.7× faster, end-to-end $f$5 speedup, mIoU drop $f$6 pp	combined pipeline

The paper also states that RadiusFPS-G sustains the highest throughput in Mpts/s across small to million-point scenes and maintains a moderate memory profile of about $f$7 MB, compared with about $f$8 MB for QuickFPS (Yu et al., 4 Jun 2026). This suggests that the method is intended not merely as a micro-optimization of the FPS kernel, but as a systems-level improvement for real-time robotic vision pipelines where both latency and memory pressure are first-order constraints.

The practical trade-off is the voxel resolution $f$9, or equivalently the voxel side length $e$0. A coarse grid reduces indexing overhead but weakens pruning; a fine grid tightens the geometric bound but increases voxel-management and cache overhead. The reported empirical sweet spot is $e$1–32 for typical indoor and outdoor scenes. The method can degenerate to classical FPS behavior when $e$2, when $e$3 is extremely large, when sample counts are very low, or for uniform spherical distributions that yield minimal pruning (Yu et al., 4 Jun 2026).

5. RadiusFPS as a radius-to-frame-rate map in foveated graphics

In the spatio-temporal foveation literature, RadiusFPS is the operational output of a perceptual model for eccentricity-dependent flicker fusion. The underlying model defines

$e$4

the critical flicker fusion threshold as a function of spatial frequency $e$5, retinal eccentricity $e$6, and display luminance $e$7. At a reference luminance $e$8, with $e$9 trolands, the base model is

$L$0

$L$1

$L$2

with fitted coefficients $L$3 reported for the relaxed fit and adjusted $L$4 (Krajancich et al., 2021).

Luminance dependence is incorporated via pupil diameter $L$5, retinal illuminance $L$6, and a Ferry–Porter gain: $L$7

$L$8

with fitted parameters $L$9, $r$0, and $r$1. The model is based on measurements obtained with a custom near-eye DLP projector at $r$2 Hz, monocular green channel, peak luminance $r$3, using 2D Gabor wavelets at six spatial frequencies and eccentricities up to about $r$4, with nine subjects in a 2AFC QUEST protocol (Krajancich et al., 2021).

The RadiusFPS computation then proceeds from content to scheduling. For each pixel or patch at retinal radius $r$5, one decomposes the display content into spatial-frequency bands, computes the retinal eccentricity of each band relative to gaze, evaluates $r$6, and defines the per-radius allowed frame rate by

$r$7

or, conservatively, by the highest-frequency band. The result is clamped to display limits and may be radially smoothed to avoid discontinuities. In a real-time pipeline, gaze from an eye tracker is converted to an eccentricity map, the CFF lookup produces a per-tile FPS budget, and rendering rate, shading rate, or frame insertion is adjusted per tile before compositing (Krajancich et al., 2021).

6. Validation, applications, and conceptual separation of the two usages

For the foveated-graphics RadiusFPS, validation is perceptual. A second user study with $r$8 presented video clips with flicker-modulated Gabor patches above and below model-predicted CFF, collected quality ratings on a $r$9–$M$00 scale, and computed DMOS. The reported result is that only the RadiusFPS-based binary predictor, phrased as “flicker visible/invisible,” correlated highly with DMOS, with Pearson $M$01 and $M$02, whereas PSNR, SSIM, and VMAF failed to capture flicker thresholds. The associated bandwidth analysis states that spatial-only foveation yields compression gains of about $M$03–$M$04 for typical VR fields of view, while spatio-temporal foveation using CFF provides an additional $M$05–$M$06 saving, for a total of up to about $M$07–$M$08 versus un-foveated and about $M$09–$M$10 over spatial-only approaches (Krajancich et al., 2021).

Its listed applications are gaze-contingent rendering, video compression, and display hardware strategies such as dynamic backlight strobing and multi-rate scanning. Its limitations are equally explicit: the model targets binary CFF rather than a full spatio-temporal contrast sensitivity function, uses monocular fixed-fixation measurements, is measured only up to $M$11 cpd and extrapolated via a spatial-acuity model, assumes rotational symmetry and orientation-independence, and does not account for crowding, eye-motion blur, or chromatic channels (Krajancich et al., 2021).

For the point-cloud RadiusFPS, the applications are robotic perception pipelines that require high-quality FPS-style sampling under strict latency and memory budgets. Its limitations follow from the pruning mechanism rather than from perceptual modeling: worst-case time remains $M$12, pruning weakens under coarse voxelization or unfavorable distributions, and the choice of $M$13 determines the balance between tighter bounds and indexing overhead (Yu et al., 4 Jun 2026).

The two usages therefore occupy different conceptual roles. In one case, RadiusFPS is an exact geometric acceleration of an existing combinatorial sampling operator. In the other, it is a gaze-contingent frame-rate allocation derived from a psychophysical model. A plausible implication is that the shared name reflects the generic idea of mapping “radius” to an “FPS”-related quantity, but the underlying mathematics, implementation strategies, hardware assumptions, and evaluation protocols are entirely different.