FastPoint: Diverse Point-Centric Systems Overview

• FastPoint is a reused label in arXiv for multiple point-centric methods across domains like weak supervision, LiDAR 3D detection, rendering, and human-robot interaction.
• It includes varied approaches such as pointly-supervised instance segmentation reducing annotation cost, two-stage LiDAR detectors combining voxel and point refinement, and learned sampling acceleration for PointNet++.
• Additional implementations cover scene-scale 3D segmentation backbones, real-time Unity point-cloud rendering, and efficient point-set formulations for tracking and registration.

FastPoint is a reused label in the arXiv literature rather than a single canonical method. It refers to several unrelated point-centric systems, including a pointly-supervised route to instance segmentation, a two-stage LiDAR 3D detector, a software-only accelerator for PointNet++-style inference, a real-time RGB-D pointing detector, and, as the naming variant “FastPoints,” a Unity point-cloud renderer (Cheng et al., 2021, Chen et al., 2019, Lee et al., 31 Jul 2025, Azari et al., 2019, Neuman-Donihue et al., 2023). The shared terminology reflects a recurring emphasis on point-level primitives, sparse computation, and reduced annotation or inference cost, but the underlying tasks, architectures, and guarantees differ substantially.

1. Disambiguation and naming

The main uses of the name span weak supervision, 3D detection, rendering, sampling acceleration, and scene-scale point-cloud backbones. A frequent source of confusion is that some systems use the exact name “FastPoint,” some use “Fast Point” followed by a task label, and the Unity renderer is canonically named “FastPoints” in the plural (Neuman-Donihue et al., 2023, Park et al., 2021).

Usage	Domain	Canonical paper
FastPoint route in pointly-supervised instance segmentation	2D instance segmentation	(Cheng et al., 2021)
Fast Point R-CNN	LiDAR 3D object detection	(Chen et al., 2019)
FastPoint	FPS acceleration for PointNet++-style inference	(Lee et al., 31 Jul 2025)
Fast Point Transformer	Scene-scale 3D segmentation and detection	(Park et al., 2021)
FastPoint / FastPoints naming variant	Unity point-cloud rendering	(Neuman-Donihue et al., 2023)
FastPoint	RGB-D pointing-gesture detection for HRI	(Azari et al., 2019)

Two clarifications are central. First, “FastPoint” in weakly supervised instance segmentation is a description of a pointly-supervised route introduced in “Pointly-Supervised Instance Segmentation,” not the paper title itself (Cheng et al., 2021). Second, “FastPoints” is the correct name of the Unity rendering system; references using the singular form are naming variants of the same renderer (Neuman-Donihue et al., 2023).

2. Pointly-supervised instance segmentation

In weakly supervised instance segmentation, FastPoint denotes an annotation and training scheme based on a category-labeled bounding box plus binary labels for a small number of points sampled uniformly inside the box (Cheng et al., 2021). The labeling primitive is minimal: for each sampled point $x$ inside the box, the annotator assigns $y \in \{0,1\}$ indicating object or background. The recommended setting is $N = 10$ points per object. On COCO, polygon masks take on average $79.2$ s per instance, whereas a box can be drawn in about $7$ s via extreme points, and point labeling is reported as $0.9$ s per point. The resulting cost for box plus $10$ points is $7 + 10 \times 0.9 = 16$ s per object, approximately $5\times$ faster than full mask annotation; with upstream COCO pipeline stages included, the totals are about $59.2$ s for box plus $y \in \{0,1\}$0 points versus $y \in \{0,1\}$1 s for masks.

The training modification is deliberately small. For a mask head prediction $y \in \{0,1\}$2 and labeled points $y \in \{0,1\}$3, the mask loss is computed only on the labeled points:

$y \in \{0,1\}$4

Unlabeled pixels are ignored. For grid-based heads such as Mask R-CNN, $y \in \{0,1\}$5 is obtained by bilinear interpolation on the predicted mask grid; detection losses remain unchanged. The same principle extends to image-level heads such as CondInst. A simple augmentation subsamples half of the available ground-truth points for each ROI at each iteration, which is reported to increase training variability and reduce overfitting.

The paper also introduces Implicit PointRend, a point-native mask head aligned with this supervision. For each detected instance $y \in \{0,1\}$6, dynamic parameters $y \in \{0,1\}$7 define an implicit function $y \in \{0,1\}$8 over points inside the box:

$y \in \{0,1\}$9

Inputs include fine-grained multi-scale image features sampled at the exact location and relative point coordinates encoded with random Fourier positional features. Training again uses a single point-level BCE loss, with a small $N = 10$0 penalty of weight $N = 10$1 on $N = 10$2.

Empirically, Mask R-CNN with $N = 10$3 points per object achieves near-parity with full masks across several datasets: COCO $N = 10$4 AP versus $N = 10$5 AP, PASCAL VOC $N = 10$6 AP50 versus $N = 10$7 AP50, Cityscapes $N = 10$8 AP versus $N = 10$9 AP, and LVISv1.0 $79.2$0 AP versus $79.2$1 AP. On COCO, Implicit PointRend improves point-supervised performance over original PointRend, reaching $79.2$2 AP versus $79.2$3 AP with ResNet-50-FPN, and with ResNeXt-101-32×8 it reaches $79.2$4 AP, matching or exceeding fully supervised Mask R-CNN at $79.2$5 AP. The reported robustness characteristics are similarly notable: point labels agree with COCO masks by approximately $79.2$6 and with LVIS masks by approximately $79.2$7; flipping $79.2$8 of point labels at random yields a $79.2$9 AP drop, and concentrating the errors within the $7$0 closest points to boundaries yields $7$1 AP. Uniform random point sampling is reported to outperform boundary-biased sampling.

3. Fast Point R-CNN for LiDAR 3D detection

“Fast Point R-CNN” is a two-stage framework for point-cloud based 3D object detection that combines voxelized processing in the proposal stage with raw-point refinement in the second stage (Chen et al., 2019). The task is 3D detection from a single LiDAR sweep, with outputs as oriented 3D boxes and scores. The design motivation is explicit: voxelization regularizes sparse, irregular point clouds for efficient convolution, but quantization and downsampling degrade fine localization; the second stage reintroduces raw point coordinates to recover geometric precision.

Stage 1, VoxelRPN, operates on a voxel grid over the KITTI range $7$2, $7$3, $7$4 with voxel size $7$5 m, yielding a grid of size $7$6. Each voxel keeps up to $7$7 points and uses an $7$8-channel MLP as a compact per-voxel encoder. The backbone uses six lightweight 3D convolution layers followed by three 2D convolution blocks on BEV features and HyperNet-style fusion. Anchors per location use four orientations $7$9, and Stage 1 predicts objectness and anchor-relative 3D box regression targets.

Stage 2, RefinerNet, processes interior points from each proposal. For each point, it forms a coordinate feature from canonized point coordinates and an indexed convolutional feature by gathering the Stage-1 BEV feature at the corresponding location:

$0.9$0

The coordinate and indexed features are concatenated and modulated with a channel-wise attention gate:

$0.9$1

A light PointNet then aggregates point features and regresses offsets to the $0.9$2 canonized 3D box corners. The refinement head is trained only on positive proposals and uses Smooth L1 loss.

The reported runtime is $0.9$3 s for VoxelRPN and $0.9$4 s end-to-end, corresponding to about $0.9$5 FPS on an NVIDIA Tesla P40. On KITTI test for Cars, the method reports 3D AP $0.9$6 for Easy/Moderate/Hard and BEV AP $0.9$7. On validation, Moderate 3D AP at IoU $0.9$8 improves from $0.9$9 for VoxelRPN to $10$0 for the full method, and far-range Moderate $10$1D@$10$2 from $10$3–$10$4 m improves from $10$5 to $10$6. Ablations attribute gains to low-level 3D convolutions, higher input resolution, MIXUP augmentation, more anchor orientations, attention-based feature fusion, and the canonized corner loss.

4. Sampling and inference acceleration in point-cloud networks

A more recent FastPoint is a software-only acceleration method for PointNet++-style inference that targets the bottlenecks of farthest point sampling (FPS), Ball Query, and k-NN (Lee et al., 31 Jul 2025). Let $10$7, let $10$8 be the sampled set after iteration $10$9, and define

$7 + 10 \times 0.9 = 16$0

The method models the sequence $7 + 10 \times 0.9 = 16$1 as the “minimum distance curve.” After a short warm-up using exact FPS, a $7 + 10 \times 0.9 = 16$2-layer MLP predicts the remaining curve, with reported MAPE of $7 + 10 \times 0.9 = 16$3 on S3DIS, $7 + 10 \times 0.9 = 16$4 on ScanNet, and $7 + 10 \times 0.9 = 16$5 on SemanticKITTI. The resulting Minimum Distance Prediction Sampling (MDPS) partitions the iterations into $7 + 10 \times 0.9 = 16$6 default segments, builds per-segment exclusion lists from a fused all-pairs GPU kernel, and then performs segment-wise sampling via bitmaps without further distance computation. Overestimation is handled by early termination and fallback to exact FPS.

The same precomputed structures are reused for neighbor search. Ball Query becomes reuse of a prebuilt radius-specific exclusion list, and k-NN is restricted to a small candidate set. The reported outcome on NVIDIA RTX 3090 is a geometric-mean $7 + 10 \times 0.9 = 16$7 end-to-end speedup across S3DIS, ScanNet, and SemanticKITTI, a $7 + 10 \times 0.9 = 16$8 sampling speedup versus FPS, and a $7 + 10 \times 0.9 = 16$9 neighbor-search speedup, with negligible mIoU changes. For example, PointVector-L changes from $5\times$0 to $5\times$1 on S3DIS, from $5\times$2 to $5\times$3 on ScanNet, and from $5\times$4 to $5\times$5 on SemanticKITTI. Sampling quality, measured by average minimum distance, remains at $5\times$6 of FPS on S3DIS, $5\times$7 on ScanNet, and $5\times$8 on SemanticKITTI.

Earlier FPS acceleration work provides useful context. Adjustable FPS (AFPS) divides an approximately sorted point cloud into $5\times$9 sectors and samples $59.2$0 points simultaneously, reducing complexity from $59.2$1 to $59.2$2; with nearest-point-distance-updating (NPDU), the update cost becomes $59.2$3, independent of $59.2$4 for fixed $59.2$5 (Li et al., 2022). The paper reports AFPS speedups of $59.2$6–$59.2$7 over original FPS and AFPS+NPDU speedups of $59.2$8–$59.2$9 on $y \in \{0,1\}$00K–$y \in \{0,1\}$01K-point clouds, with ShapeNet part-segmentation instance-average mIoU of $y \in \{0,1\}$02, only $y \in \{0,1\}$03 below original FPS.

A later exact framework, RadiusFPS, situates FastPoint as a complementary learned sampler (Yu et al., 4 Jun 2026). RadiusFPS and RadiusFPS-G accelerate FPS through spherical voxel pruning and a coordinate-wise point-skip test while preserving the standard FPS update rule under the same initialization and tie-breaking policy. In that evaluation, FastPoint is plugged into the first-layer sampling stage of PointMetaBase and PointVector. The combination FastPoint + RadiusFPS-G yields the fastest end-to-end runtime among the tested configurations: for PointMetaBase, S3DIS drops from $y \in \{0,1\}$04 s with GPU-FPS to $y \in \{0,1\}$05 s, ScanNet from $y \in \{0,1\}$06 s to $y \in \{0,1\}$07 s, and SemanticKITTI from $y \in \{0,1\}$08 s to $y \in \{0,1\}$09 s. The same paper reports up to $y \in \{0,1\}$10 sampling speedup and up to $y \in \{0,1\}$11 end-to-end speedup relative to GPU-FPS, alongside mIoU reductions that are small indoors and larger on SemanticKITTI. A common misconception is that FastPoint is exact FPS; the RadiusFPS analysis makes the distinction explicit: RadiusFPS is exact under fixed seed and deterministic tie-breaking, whereas FastPoint is predictive and may deviate from exact FPS behavior.

5. Scene-scale point processing and rendering

The phrase “Fast Point” also appears in large-scale scene processing. “Fast Point Transformer” is a scene-level backbone for 3D semantic segmentation and 3D detection that replaces kNN-based point attention with centroid-aware voxelization/devoxelization, voxel hashing, and a lightweight self-attention (LSA) layer (Park et al., 2021). Input points $y \in \{0,1\}$12 are voxelized into non-empty voxels with centers $y \in \{0,1\}$13, centroids $y \in \{0,1\}$14, and features

$y \in \{0,1\}$15

Attention uses centroid-aware features $y \in \{0,1\}$16 and a decomposed positional encoding in which continuous offsets are split into a per-voxel absolute term and a compact discretized relative token. This reduces positional-memory cost from $y \in \{0,1\}$17 to $y \in \{0,1\}$18 and avoids the softmax instability described for sparse and variable-sized neighborhoods. On S3DIS Area 5, the model processes a scene in $y \in \{0,1\}$19 s, reported as $y \in \{0,1\}$20 faster than Point Transformer, while reaching $y \in \{0,1\}$21 mIoU at $y \in \{0,1\}$22 cm voxel size and $y \in \{0,1\}$23 mIoU with rotation averaging. On ScanNet validation it reports $y \in \{0,1\}$24 mIoU, and as a VoteNet backbone it reaches $y \in \{0,1\}$25 [email protected] and $y \in \{0,1\}$26 [email protected].

In graphics and visualization, “FastPoints” is a distinct Unity point-cloud renderer with drag-and-drop import of PLY, LAS, and LAZ files and an online out-of-core octree construction pipeline (Neuman-Donihue et al., 2023). On import, the system uniformly decimates to a default $y \in \{0,1\}$27M-point proxy and renders it immediately so that the Unity Editor remains responsive, while an out-of-core Potree-style octree is built asynchronously in the background. Rendering uses GPU buffers per node and DrawProceduralNow, avoiding per-node GameObject overhead. The reported time-to-interactivity on a MacBook Pro 14" (2021), M1 Pro, 16 GB RAM is $y \in \{0,1\}$28 s for NEON PLY ($y \in \{0,1\}$29M points), $y \in \{0,1\}$30 s for Great Hall PLY ($y \in \{0,1\}$31M points), and $y \in \{0,1\}$32 s for Oplontis 14 PLY ($y \in \{0,1\}$33M points). During online construction, the decimated proxy runs at more than $y \in \{0,1\}$34 FPS in the reported camera orbit, with an initial spike near $y \in \{0,1\}$35 FPS dropping to about $y \in \{0,1\}$36 FPS once the proxy is first loaded. The renderer is demonstrated on clouds up to approximately $y \in \{0,1\}$37 billion points. Here, the naming issue is explicit: “FastPoints” is the correct name, and singular “FastPoint” is only a variant used in references or queries.

6. Specialized point-centric systems and related usages

In human-robot interaction, FastPoint denotes a real-time pointing-gesture detector from a single RGB-D camera (Azari et al., 2019). The system uses an Intel RealSense ZR300 with pixel-aligned RGB and depth, runs a YOLOv2-derived detector for hands and faces on RGB, and lifts detections into 3D by back-projecting aligned depth pixels:

$y \in \{0,1\}$38

The pointing direction is formed as

$y \in \{0,1\}$39

Two ROI depth-filtering strategies are reported: CoBB, which keeps pixels inside a circle with radius $y \in \{0,1\}$40, and DBSCAN clustering on depth. The detector runs at about $y \in \{0,1\}$41 ms per RGB frame on an NVIDIA GTX 970 and the full system runs better than $y \in \{0,1\}$42 Hz on commodity hardware, though DBSCAN can reduce the output rate to about $y \in \{0,1\}$43 Hz at $y \in \{0,1\}$44–$y \in \{0,1\}$45 m because of sparse depth. Angular error against VICON varies from approximately $y \in \{0,1\}$46 to $y \in \{0,1\}$47, increasing with distance, and mean floor-target error is reported as $y \in \{0,1\}$48 cm at $y \in \{0,1\}$49 m, $y \in \{0,1\}$50 cm at $y \in \{0,1\}$51 m, $y \in \{0,1\}$52 cm at $y \in \{0,1\}$53 m, $y \in \{0,1\}$54 cm at $y \in \{0,1\}$55 m, and $y \in \{0,1\}$56 cm at $y \in \{0,1\}$57 m. The system stabilizes predictions with Kalman filtering and accepts robot goals only after a $y \in \{0,1\}$58-frame covariance check.

Point-centric speedups also appear in online MOTS, though the canonical model name there is PointTrack rather than FastPoint (Xu et al., 2020). The method converts each instance mask into two unordered 2D point sets: foreground points inside the mask and environment points inside an enlarged bounding box but outside the mask. Default sampling uses $y \in \{0,1\}$59 foreground points and $y \in \{0,1\}$60 environment points, with features built from relative offsets, RGB, and environment semantics. A dual-branch PointNet-style encoder produces a $y \in \{0,1\}$61-D instance embedding used in a Hungarian association step with similarity

$y \in \{0,1\}$62

where $y \in \{0,1\}$63 and the matching threshold is $y \in \{0,1\}$64. The full online MOTS pipeline runs at $y \in \{0,1\}$65 s per frame, approximately $y \in \{0,1\}$66 FPS on KITTI MOTS, and is reported as $y \in \{0,1\}$67 higher MOTSA and $y \in \{0,1\}$68 times faster over MOTSFusion.

A different fast point-set formulation arises in nonrigid registration through “Fast Coherent Point Drift” (Feng et al., 2020). Standard CPD solves a dense linear system for the GRBF coefficients $y \in \{0,1\}$69 at each EM iteration, leading to $y \in \{0,1\}$70 matrix inversion cost. The fast implementation introduces the corresponding constraint

$y \in \{0,1\}$71

which simplifies the M-step to

$y \in \{0,1\}$72

With a one-time eigenvalue decomposition $y \in \{0,1\}$73, the update becomes

$y \in \{0,1\}$74

so each iteration updates only a diagonal matrix and performs matrix multiplications of approximate cost $y \in \{0,1\}$75, with a further low-rank approximation reducing the per-iteration cost to $y \in \{0,1\}$76. On the Bunny dataset with $y \in \{0,1\}$77k points and $y \in \{0,1\}$78 iterations, the paper reports CPD total runtime of $y \in \{0,1\}$79 s versus $y \in \{0,1\}$80 s for Fast-CPD-L, and a spatial-transform-time reduction from $y \in \{0,1\}$81 s total to $y \in \{0,1\}$82 s total for the low-rank fast variant. This usage is methodologically unrelated to the FPS and point-supervision literature, but it exemplifies the same naming pattern: “fast” methods built around point-set primitives rather than dense image operators.