Event-LiDAR: 3D Eventification for Efficient Point Cloud Processing¶
Conference: ECCV 2026
Paper: ECCV Official
Code: https://github.com/scsrp/event-lidar
Area: Autonomous Driving
Keywords: 3D eventification, LiDAR point cloud, temporal redundancy reduction, 3D object detection, efficient perception
TL;DR¶
Addressing the severe spatial-temporal redundancy in multi-scan LiDAR perception, Event-LiDAR introduces a training-free 3D eventification front-end that approximates short-term geometric evolution using local first-order geometric models and extracts unpredictable signed geometric deviations as 3D events, cutting over 70% of points while preserving full-scan detection accuracy with up to a 23% end-to-end inference speedup.
Background & Motivation¶
Modern autonomous driving and robotic perception systems continuously acquire high-resolution LiDAR scans at high temporal frequencies (e.g., 10–20 Hz) to monitor dynamic traffic environments. To overcome the extreme spatial sparsity of individual scans and capture motion dynamics, conventional 3D detection pipelines aggregate multi-scan point clouds into a single concatenated frame. However, this dense accumulation incurs immense temporal redundancy: large expanses of the surrounding environment—such as asphalt roads, building facades, and roadside structures—remain geometrically static across consecutive frames, yet detectors repeatedly process, voxelize, and extract features from these near-identical points, causing unnecessary computational overhead, memory footprints, and latency bottlenecks.
While video compression standards (e.g., predictive coding in MPEG) and bio-inspired event cameras have long leveraged change-based sensing to achieve low-bandwidth transmission, adapting this principle to 3D LiDAR point clouds is hindered by fundamental differences in data structure. Unlike dense, regular 2D pixel grids, 3D LiDAR point clouds are irregular, spatially sparse, and highly viewpoint-dependent. Directly differencing range or depth images produces severe discretization artifacts that amplify with distance, swamping meaningful signals. Conversely, direct voxel occupancy differencing or point-to-point residual checks fail under ego-motion: continuous viewpoint shifts and stochastic beam sampling cause large swathes of static background to lack exact 1:1 correspondences, triggering overwhelming false-positive event activations. Even recent point-level residual pruning methods (such as RPP in FSD++) struggle with newly revealed static surfaces, confusing unobserved static regions with dynamic changes.
This paper tackles this core tension by arguing that correspondence absence must not be equated with structural motion, and formulates 3D event extraction as a local temporal geometric estimation problem under sparse, viewpoint-dependent observations. By establishing a local first-order geometric model over the previous scan and extrapolating it to freshly observed regions, the system accurately predicts and suppresses expected geometric continuations. Core idea: formulate 3D event extraction as a temporal estimation problem using local first-order line and plane models built from consecutive scans, retaining only unpredictable signed geometric deviations as 3D events via millisecond-scale, label-free preprocessing.
Method¶
Overall Architecture¶
Event-LiDAR operates as a lightweight, label-free, and architecture-agnostic geometric preprocessor situated between raw sensor input and downstream 3D detectors. Its primary goal is to prune temporally predictable background points while retaining structural variations and motion cues. The temporal differentiation pipeline proceeds in four stages: first, ego-motion compensation aligns the current scan into the coordinate frame of the previous scan; second, an equirectangular projection grid enables fast \(O(1)\) neighborhood querying in the previous scan, from which local first-order geometric primitives (lines or planes) are constructed; third, the orthogonal projection and signed deviation of current points against these primitives are calculated, with smooth extrapolation applied to newly exposed viewpoints; fourth, an event thresholding rule filters out predictable points, emitting a sparse eventified point cloud augmented with temporal deviation residuals.
%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
A["Raw Point Cloud & Ego-Pose"] --> B["Ego-Motion Compensation & Equirectangular Grid Indexing<br/>Coordinate alignment & O(1) neighbor retrieval"]
B --> C["Local First-Order Geometric Modeling & Signed Deviation<br/>Fit local line/plane primitives and measure projection distance"]
C --> D["Viewpoint Extrapolation & Adaptive Event Thresholding<br/>Extrapolate smooth background & filter redundant points"]
D --> E["Event-Aware Network Reallocation & 3D Object Detection<br/>Reallocate model capacity to early stages for sparse inputs"]
Key Designs¶
1. Ego-Motion Compensation & Equirectangular Grid Indexing: eliminating motion artifacts and enabling constant-time neighbor retrieval
To suppress false deviations induced by sensor movement, let \(\hat{P}_t\) denote the current scan in its native sensor frame. Using a rigid body transformation \(T_t \in \text{SE}(3)\) estimated over short intervals (\(\le 0.1\text{ s}\)) via odometry or IMU, the scan is backward-warped into the coordinate system of the preceding scan \(P_{t-1}\): $\(P_t = T_t \hat{P}_t\)$ Because conventional \(k\text{d}\)-tree spatial queries in 3D Euclidean space are computationally prohibitive for low-latency automotive systems, Event-LiDAR projects the previous scan \(P_{t-1}\) onto the 2D equirectangular projection domain. This spherical grid structure enables constant-time (\(O(1)\) on average) retrieval of local neighborhood sets \(\mathcal{N}(p) \subset P_{t-1}\) for each warped point \(p \in P_t\), eliminating indexing bottlenecks during runtime.
2. Local First-Order Geometric Modeling & Signed Deviation: analytic primitives replacing costly surface fitting
Point-to-point Euclidean distances are inherently noisy in sparse LiDAR scans due to angular beam spacing and laser ray fluctuations. Event-LiDAR circumvents expensive iterative surface fitting (such as PCA or SVD) by constructing closed-form, first-order geometric primitives \(\mathcal{M}(p) \subset \mathbb{R}^3\) directly from the queried neighbors: a 3-point local plane or a 2-point local line segment, with a graceful fallback hierarchy of plane \(\to\) line \(\to\) point. The current point \(p\) is then orthogonally projected onto \(\mathcal{M}(p)\) to establish its reference footpoint: $\(\Pi(p) = \arg\min_{x \in \mathcal{M}(p)} \|p - x\|_2\)$ To capture whether a surface is moving toward or away from the sensor, the temporal deviation is defined as a signed scalar \(\Delta d(p) = \phi(p) \|p - \Pi(p)\|_2\), where the sign function is governed by sensor range: $\(\phi(p) = \text{sign}(\|p\|_2 - \|\Pi(p)\|_2)\)$ This distinguishes geometric advance from recession without iterative surface tracking.
3. Viewpoint Extrapolation & Adaptive Event Thresholding: suppressing spurious activations in newly exposed regions
As a vehicle advances, ego-motion reveals previously occluded or unobserved areas (e.g., newly visible road surfaces ahead). Traditional residual approaches fail here because unobserved points have no corresponding neighbors in \(P_{t-1}\), causing them to be falsely classified as events. Event-LiDAR recognizes that most newly exposed regions belong to continuous, low-frequency geometric structures (e.g., planar roads and vertical walls). When queried neighbors do not enclose the projection \(\Pi(p)\), the model extrapolates the local primitive \(\mathcal{M}(p)\) along scanlines. An event is triggered only when the magnitude of the geometric deviation exceeds a range-aware uncertainty threshold \(\tau(r_{\min})\): $\(E(p) = \begin{cases} 1, & \text{if } |\Delta d(p)| > \tau(r_{\min}) \\ 0, & \text{otherwise} \end{cases}\)$ where \(r_{\min} = \min(\|p\|_2, \|\Pi(p)\|_2)\). In practice, setting \(\tau\) to a calibrated constant \(\tau_0\) (0.072 m for nuScenes, 0.069 m for Waymo) reliably prunes roughly 80% of points per differentiated scan while preserving salient object boundaries.
4. Event-Aware Network Reallocation: shifting capacity to early stages for sparse inputs
Eventified scans compress the temporal stream into either hybrid configurations (\(1\text{F}+(N-1)\text{T}\), combining a full reference frame with eventified historical scans) or pure event streams (\(N\text{T}\)), where points are represented as feature vectors \(f = (x, y, z, r, t_{\text{offset}}, \Delta d)\). Because eventified point clouds are significantly sparser and concentrated along motion boundaries, standard backbone architectures designed for uniform dense points can suffer from feature under-representation in early layers. Event-LiDAR proposes an Event-Aware (EA) network reconfiguration: while preserving the total parameter budget (e.g., 15.6M vs. 15.7M on PTv3), capacity (channel width and layer depth) is shifted from deep stages to the initial input and shallow voxel layers. This allows the model to extract richer representations from sparse event signals at minimal computational cost.
Loss & Training¶
Event-LiDAR functions as an unsupervised, non-parametric geometric front-end requiring no task-specific training loss. For downstream 3D object detection, detectors (CenterPoint and PTv3) are trained with standard multi-task losses, including Focal Loss for heatmap classification, L1/Smooth-L1 regression losses for 3D bounding box dimensions and offsets, and velocity/heading angle losses. Models are trained using the AdamW optimizer with an initial learning rate of \(3 \times 10^{-4}\) and batch size 16. Because input point volume drops by over 70%, training throughput increases by 14% to 23% alongside substantial inference speedups.
Key Experimental Results¶
Main Results¶
Evaluated on nuScenes (10-scan concatenation) and Waymo Open Dataset (3-scan aggregation) using CenterPoint and Point Transformer V3 (PTv3), Event-LiDAR achieves significant latency reductions and point pruning with negligible detection degradation.
| Dataset | Backbone | Input Mode / Method | Pt. Red. (%) | Time (ms) | Speedup | mAP / L2 mAP | NDS / L2 mAPH |
|---|---|---|---|---|---|---|---|
| nuScenes | CenterPoint | 10F (Full-scan baseline) | 0.0 | 39.1 | 1.00× | 59.6 | 65.9 |
| nuScenes | CenterPoint | 10R (Random 20%) | 80.0 | 34.3 | 1.14× | 49.9 | 59.5 |
| nuScenes | CenterPoint | 10T (Ours pure event) | 79.9 | 34.9 | 1.12× | 58.7 | 65.1 |
| nuScenes | CenterPoint | 1F+9T (Ours hybrid) | 71.9 | 35.9 | 1.09× | 59.5 | 65.5 |
| nuScenes | PTv3 | 10F (Full-scan baseline) | 0.0 | 71.2 | 1.00× | 63.5 | 68.5 |
| nuScenes | PTv3 | 10R (Random 20%) | 80.0 | 53.3 | 1.34× | 53.2 | 61.5 |
| nuScenes | PTv3 | 10M (Mapless-MOS) | 79.7 | 51.1 | 1.39× | 51.4 | 59.8 |
| nuScenes | PTv3 | 10V (FSD++ RPP) | 79.4 | 58.1 | 1.23× | 54.9 | 62.5 |
| nuScenes | PTv3 | 10D (M-detector) | 79.1 | 46.6 | 1.53× | 34.2 | 49.8 |
| nuScenes | PTv3 | 10T (Ours pure event) | 79.9 | 53.4 | 1.33× | 61.8 | 67.3 |
| nuScenes | PTv3 | 1F+9T (Ours hybrid) | 71.9 | 57.8 | 1.23× | 63.1 | 68.1 |
| Waymo | CenterPoint | 3F (Full-scan baseline) | 0.0 | 39.4 | 1.00× | 67.7 | 66.2 |
| Waymo | CenterPoint | 1F+2T (Ours hybrid) | 53.5 | 35.6 | 1.10× | 67.1 | 65.6 |
| Waymo | PTv3 | 3F (Full-scan baseline) | 0.0 | 87.9 | 1.00× | 69.7 | 68.3 |
| Waymo | PTv3 | 1F+2T (Ours hybrid) | 53.5 | 73.1 | 1.20× | 68.8 | 67.5 |
Ablation Study¶
1. Primitive Fitting Types & Point Retention Distribution
Point retention rates for dynamic objects, static objects, and background on nuScenes highlight the selective power of first-order geometric models.
| Method / Config | Dynamic Retained (%) | Static Retained (%) | Background Retained (%) | Note |
|---|---|---|---|---|
| Random (20%) | 20.1 | 20.0 | 20.0 | Unbiased uniform thinning |
| Height Filtering H(0.3m) | 83.4 | 82.5 | 41.7 | Removes some ground; limited point reduction |
| Height Filtering H(80%) | 8.0 | 7.5 | 21.3 | Aggressive cut discards critical object points |
| Range Image I (Residual image) | 33.6 | 23.3 | 19.8 | Quantization error diminishes dynamic selectivity |
| \(T_{\text{point}}\) (Point distance) | 36.5 | 16.6 | 20.4 | Lacks surface fit; loses static object context |
| \(T_{\text{line}}\) (Line model, default) | 51.4 | 28.4 | 19.6 | Best trade-off between speed and retention |
| \(T_{\text{plane}}\) (Plane model) | 53.4 | 28.1 | 19.2 | Highest dynamic retention; marginally higher compute |
2. Impact of Event-Aware (EA) Network Capacity Reallocation
Ablation on PTv3 under 10F and 1F+9T inputs on nuScenes demonstrates the efficiency gains of shifting network capacity toward the input stage.
| Input Mode | Enable EA | #Param | Time (ms) | mAP (%) | NDS (%) | Efficiency Gain \(\Delta\text{mAP}/\Delta t\) |
|---|---|---|---|---|---|---|
| 10F | No | 15.6M | 61.6 | 62.3 | 67.7 | — |
| 10F | Yes | 15.7M | 71.2 | 63.5 | 68.5 | 0.125 |
| 1F+9T | No | 15.6M | 52.3 | 62.0 | 67.1 | — |
| 1F+9T | Yes | 15.7M | 57.8 | 63.1 | 68.1 | 0.207 |
Key Findings¶
- Superior selectivity over random subsampling and MOS: On nuScenes at an 80% point reduction ratio, random subsampling severely drops PTv3 mAP by 10.3% (from 63.5% to 53.2%). Moving object segmentation (MOS) techniques (such as Mapless-MOS and M-detector) discard all static background objects, resulting in catastrophic mAP collapses to 51.4% and 34.2%. In contrast, Event-LiDAR's local geometric modeling retains 51.4% of dynamic points and 28.4% of static object points, enabling 10T to maintain 61.8% mAP, while 1F+9T reaches 63.1% mAP (virtually matching the 63.5% full-scan ceiling).
- Backbone acceleration drives latency reduction: Profiling on PTv3 reveals that 1F+9T delivers a 32% speedup in backbone feature extraction (and up to 48% under 10T). Heavy attention/sparse convolution backbones benefit directly from the reduced voxel occupancy.
- Ultra-low preprocessing latency preserves end-to-end gains: Implemented with SIMD vectorization on a single CPU thread, Event-LiDAR executes in just 0.34 ms per frame on nuScenes and 1.64 ms on Waymo. By contrast, M-detector requires 26.8–78.9 ms per frame on 16 threads, completely negating downstream inference gains.
- Robustness to motion noise and vertical resolution: Downsampling the reference vertical resolution on Waymo from 64 channels to 32 and 16 lines preserves L2 mAP at 66.5% and 66.2%. Injecting synthetic Gaussian rotation and translation noise well beyond standard automotive IMU drift causes no abrupt drops in mAP or NDS.
Highlights & Insights¶
- Formulating eventification as analytic surface estimation: Bypasses the resolution artifacts of 2D range images by directly fitting analytic line and plane primitives in 3D sensor space, achieving stable event extraction without numerical optimization overhead.
- Viewpoint extrapolation for occlusion handling: Resolves the classic flaw of correspondence-based pruning where newly observed static areas are mislabeled as motion, using smooth first-order extrapolation to eliminate false events.
- Capacity reallocation tailored to event sparsity: Demonstrates that sparse event inputs allow early-stage network expansion without runtime explosion, achieving higher accuracy gains per unit latency (\(\Delta\text{mAP}/\Delta t = 0.207\)).
Limitations & Future Work¶
- Dependency on inter-frame ego-motion estimates: The framework relies on accurate short-term relative poses from odometry or IMUs. Severe kinematic errors or extreme vehicle jolting could trigger local false-positive events.
- Cold-start and single-scan limitations: When stationary or starting from a single frame, inter-scan differentiation is unavailable. Furthermore, the pipeline currently treats events as point features rather than performing dense motion segmentation or tracking.
- Future directions: The authors plan to investigate recursive temporal state propagation for single-scan inputs, explore explicit motion vector estimation, and extend 3D eventification to SLAM mapping and point cloud compression.
Related Work & Insights¶
- vs FSD++ (RPP): FSD++ uses residual point probing based purely on the absence of nearest neighbors in previous scans. This misclassifies newly observed static road and wall surfaces as residuals. Event-LiDAR incorporates first-order surface modeling and extrapolation, dramatically improving signal-to-noise ratio.
- vs LiDAR MOS (Mapless-MOS / M-detector): Standard MOS filters out all stationary objects (e.g., parked vehicles, traffic poles), causing 3D detection to fail on static categories. Event-LiDAR aims for redundancy reduction rather than semantic motion segmentation, retaining critical geometric contours.
- vs 2D Range Image Differencing: Pixel-wise range differencing suffers from beam divergence and angular discretization noise at long distances. Event-LiDAR operates natively in 3D Euclidean space with signed projection distances, avoiding grid degradation.
Rating¶
- Novelty: ⭐⭐⭐⭐ [Replaces naive 2D differencing and correspondence checks with analytic first-order temporal geometric estimation]
- Experimental Thoroughness: ⭐⭐⭐⭐⭐ [Evaluated on both nuScenes and Waymo with CenterPoint and PTv3 backbones, complete with preprocessing latency, noise injection, and resolution ablations]
- Writing Quality: ⭐⭐⭐⭐⭐ [Clear motivation, rigorous mathematical formulation, and transparent discussion of viewpoint dependencies and extrapolation]
- Value: ⭐⭐⭐⭐⭐ [A sub-millisecond, architecture-agnostic CPU preprocessor that reduces 70%+ points with zero accuracy penalty provides immediate practical value for embedded autonomous driving systems]