Lightweight Geometric Detection System

• Lightweight geometric detection systems are architectures that use explicit geometric primitives to constrain search space and reduce latency.
• They employ methods like shape primitives, BEV discretizations, and sparse clustering to enhance efficiency across both optical and non-optical sensors.
• These systems balance minimal learned components with geometric reasoning, offering robust, deployable solutions for embedded, autonomous, and assistive applications.

A lightweight geometric detection system is a resource-constrained perception architecture in which object detection is driven primarily by explicit geometry rather than by dense end-to-end feature learning. Across the literature, this designation encompasses systems that use shape classes and scale windows, line and ellipse primitives, pillar or Bird’s-Eye-View discretizations, sparse point-cloud clustering, oriented boxes, graph-structured sampling, and rule-based kinematic or spatial gating to reduce memory, computation, and latency while preserving task-relevant geometric fidelity (Singh et al., 2013, Liu et al., 19 Jan 2026, Houliston et al., 2018). The common objective is not a single canonical algorithm, but a recurring design principle: constrain the search space early by geometry, process only informative structures, and defer or avoid expensive downstream stages unless coarse geometric evidence is sufficient (Singh et al., 2013, Saucedo et al., 2024).

1. Conceptual scope and historical framing

The modern notion of a lightweight geometric detection system spans several research traditions. One lineage emphasizes explicit shape primitives and hierarchical geometric reasoning. "Object Detection in Real Images" proposes exploiting lines, ellipses, and quadrangles as additional features, organizing them in a multi-level codebook with conditional likelihood propagation and dynamic learning (Prasad, 2013). "Gaussian Affine Feature Detector" derives a closed-form method for recovering affine feature geometry from a Gaussian feature model, eliminating iterative affine adaptation and directly estimating position, orientation, area, and aspect ratio from scale-space and Hessian measurements (Xu et al., 2011). "Line-Circle: A Geometric Filter for Single Camera Edge-Based Object Detection" and its multilayer extension "Line-Circle-Square (LCS): A Multilayered Geometric Filter for Edge-Based Detection" formulate lightweight perception as layered expert systems operating on edges, circles, and higher-level groupings under trust-factor and ignorance-region logic (Tafrishi et al., 2017, Tafrishi et al., 2020).

A second lineage centers on geometry-first system design for embedded or assistive deployment. "Speedy Object Detection based on Shape" uses shape and scale as a two-stage gate, with dynamic scaling, clustered window mapping, and mean-of-cluster comparison to minimize computation in an in-house audio assistive system for visually impaired users (Singh et al., 2013). "aUToTrack" combines a single 2D detector with geometric 3D lifting from camera–LiDAR projection, Euclidean clustering, and linear Kalman filtering to achieve real-time CPU-only detection and tracking on an autonomous vehicle (Burnett et al., 2019). "BOX3D" similarly restricts learning to YOLOv8 masks and boxes, while 3D lifting, world-frame merging, and voxel consistency refinement remain geometric (Saucedo et al., 2024).

A third lineage derives lightweightness from representation choice. "Visual Mesh" replaces dense image grids with a graph in angular space that provides approximately constant sample density over objects of known geometry lying on a known plane (Houliston et al., 2018). "Real-Time Structural Detection for Indoor Navigation from 3D LiDAR Using Bird's-Eye-View Images" projects 3D LiDAR to 2D occupancy BEV images, then evaluates Hough, LSD, RANSAC, and YOLO-OBB within that reduced representation on a Raspberry Pi 5 without GPU acceleration (Li et al., 20 Mar 2026). "LiFT" adopts 2D cell-based pillarization rather than 3D voxels, fully sparse convolutions, and INT8 quantization to satisfy FPGA-induced constraints (Lis et al., 19 Jan 2025).

A fourth lineage applies the same principle to non-optical sensing and cooperative sensing. "A Lightweight Model-Driven 4D Radar Framework for Pervasive Human Detection in Harsh Conditions" processes sparse, anisotropic 4D radar point clouds with domain-aware filtering, two-frame accumulation, KD-tree clustering, and a rule-based 3D classifier (Liu et al., 19 Jan 2026). "VINet" globalizes heterogeneous LiDAR observations into a shared frame, extracts lightweight pillar features at nodes, and centralizes only the heavy BEV backbone, explicitly targeting system-level computational and communication costs in cooperative 3D perception (Bai et al., 2022).

This breadth suggests that "lightweight geometric detection system" is best understood as an architectural category rather than a single method family. A plausible implication is that geometry serves simultaneously as a representation prior, a computational gate, and an interpretability mechanism.

2. Core geometric representations

The defining characteristic of these systems is the use of compact geometric objects as primary carriers of evidence. In the shape-based assistive system, the representation begins with binary images, thinning, normalization, and primitive extraction into line segments, arcs, corners or pointed edges, and coarse categorical classes such as rectangle, square, circle, line, and pointed-edge (Singh et al., 2013). The system stores each object in the smallest adequate window among $W_1:4\times4$, $W_2:8\times4$, $W_3:8\times8$, $W_4:16\times8$, and $W_5:16\times16$, and uses these discrete scales as a second-level partition inside shape clusters (Singh et al., 2013).

Primitive-centric formulations are more explicit in the codebook-based and affine-feature literature. The geometric-cue framework based on lines, ellipses, and quadrangles treats primitives as low-parameter entities and aggregates them into parts and objects through a hierarchical codebook with priors $p(z)$ and conditional links $p(z_i\mid z_j)$ (Prasad, 2013). The Gaussian affine detector models a local feature as

$$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$

with $\mu$ the center and $\Sigma$ the shape matrix, allowing direct recovery of affine geometry through normalized LoG and local Hessian measurements (Xu et al., 2011).

Several systems operate on sparse spatial sets rather than on image pixels. Radar and LiDAR pipelines use 3D or 4D point clouds whose elements are already geometric measurements. In the radar framework, each point is $W_2:8\times4$0, and later stages derive cluster-level descriptors such as bounding box dimensions, compensated mean Doppler, and modal RCS (Liu et al., 19 Jan 2026). BOX3D fits 3D axis-aligned boxes $W_2:8\times4$1 from LiDAR clusters, with $W_2:8\times4$2 and $W_2:8\times4$3, and keeps $W_2:8\times4$4 because orientation is not required by later layers (Saucedo et al., 2024). LiFT discretizes LiDAR into BEV pillars with pillar size $W_2:8\times4$5 and recovers 3D box parameters from a sparse CenterHead operating on active BEV cells (Lis et al., 19 Jan 2025).

BEV is itself a lightweight geometric representation. In the indoor structural-detection framework, 3D LiDAR points are filtered by height and projected onto a $W_2:8\times4$6 binary occupancy raster covering an approximately $W_2:8\times4$7 square scene, with no Canny edge extraction required because occupancy is already sparse and binary (Li et al., 20 Mar 2026). In VINet, all nodes transform their LiDAR points into a shared global frame and then pillarize them at $W_2:8\times4$8 in BEV, with each pillar summarized by a 64-dimensional lightweight feature (Bai et al., 2022).

Graph-based sampling provides a further variation. Visual Mesh constructs rings in angular space whose spacing is determined by the object’s angular diameter, so that the expected number of mesh nodes intersecting an object remains approximately constant over distance (Houliston et al., 2018). Event-based line detection uses a regular lattice of square image blocks, each equipped with a fixed-size ring buffer $W_2:8\times4$9, and stores events locally as active or inactive elements so that line extraction can be based on bounded per-block data structures even at very high event rates (Ikura et al., 8 Oct 2025).

System	Primary representation	Deployment emphasis
Shape-based assistive detector (Singh et al., 2013)	Binary primitives + discrete windows	Low cost, low memory, low computation
Visual Mesh (Houliston et al., 2018)	Constant-density angular graph	Real-time embedded vision
4D radar framework (Liu et al., 19 Jan 2026)	Sparse point clusters with Doppler and RCS	Harsh, visibility-degraded environments
LiFT (Lis et al., 19 Jan 2025)	Sparse BEV pillars, INT8	FPGA-tailored 3D detection
BEV structural detector (Li et al., 20 Mar 2026)	Binary occupancy BEV	SBC without GPU

These representations differ in modality and dimensionality, but they share one property: they compress raw measurements into structures whose geometry is already close to the target decision space.

3. Recurrent pipeline motifs

Despite their variety, lightweight geometric detection systems repeatedly instantiate a small set of algorithmic motifs. The first is early geometric gating. In the shape-based assistive detector, search proceeds by coarse shape $W_3:8\times8$0, then by scale window $W_3:8\times8$1, then by direct access through an index $W_3:8\times8$2, and only then by mean-feature comparison $W_3:8\times8$3 (Singh et al., 2013). If no likely matching shape or scale exists, expensive stages such as segmentation refinement, cleaning, normalization, and detailed detection are skipped, and the item is declared a new object (Singh et al., 2013). BOX3D similarly uses 2D instance masks to assign LiDAR points to candidates before any 3D clustering or world-frame fusion is attempted (Saucedo et al., 2024).

The second motif is local aggregation followed by simple geometric decision rules. The radar framework filters points by RCS, azimuth, elevation, and Doppler plausibility, accumulates exactly two frames under ego-motion compensation, applies KD-tree Euclidean clustering with $W_3:8\times8$4 and minimum cluster size $W_3:8\times8$5, and finally labels a cluster as a pedestrian if size and either motion or bounded RCS conditions hold (Liu et al., 19 Jan 2026). The rule-based nature is explicit: human width is approximately $W_3:8\times8$6–$W_3:8\times8$7 and height is less than $W_3:8\times8$8 in the decision rules (Liu et al., 19 Jan 2026). In aUToTrack, 3D measurement extraction is similarly geometric: project LiDAR points into the image, crop by 2D boxes, remove ground, run Euclidean clustering, choose the best cluster by geometric heuristics, and track the resulting centroid in a world frame with a constant-velocity Kalman filter (Burnett et al., 2019).

The third motif is sparse accumulation rather than dense global processing. The event-camera pipeline stores events in fixed-capacity per-block buffers and makes detection and tracking process-driven instead of event-driven; the fitting score

$W_3:8\times8$9

depends only on local occupancy and local active-event ratios, not on any global accumulator (Ikura et al., 8 Oct 2025). Visual Mesh processes only graph nodes induced by angular sampling and their six-neighbor connectivity rather than dense pixel neighborhoods (Houliston et al., 2018). LiFT exploits the fact that BEV pillar grids are more than $W_4:16\times8$0 empty and processes only active cells through fully sparse convolutions (Lis et al., 19 Jan 2025).

The fourth motif is hierarchical grouping. The codebook approach groups primitives into parts and parts into objects through conditional propagation (Prasad, 2013). LCS groups edges into lines, then circles, then rectangles, and feeds circle and square knowledge back to the line stage via ignorance regions $W_4:16\times8$1 so that already-consistent areas are not reprocessed (Tafrishi et al., 2020). The original LC filter uses a similar interaction between line and circle experts, with trust thresholds $W_4:16\times8$2, $W_4:16\times8$3, and $W_4:16\times8$4 governing whether a region is ignored, maintained, or discarded (Tafrishi et al., 2017).

A final motif is geometric refinement after initial detection. BOX3D fits a local 3D box from the largest LiDAR cluster, merges world-frame instances by IoU, and then refines object support by sparse point-to-voxel consistency checks over the global map (Saucedo et al., 2024). The BEV indoor-navigation framework applies detector-specific cleanup, envelope merging, polar re-parameterization, DBSCAN-based clustering, Kalman filtering on wall parameters, and Manhattan-world optimization to close corners and obtain watertight layouts (Li et al., 20 Mar 2026).

These motifs collectively explain why the term "lightweight geometric detection system" recurs across otherwise unrelated sensor stacks. The systems are not merely smaller; they explicitly organize computation so that geometry determines where computation is allowed to occur.

4. Efficiency mechanisms and resource profiles

Lightweightness is achieved through explicit constraints on search, storage, arithmetic, and communication. The shape-based assistive detector quantifies several of these reductions directly. Preprocessing is $W_4:16\times8$5 in the number of pixels, scale mapping is $W_4:16\times8$6 because there are five windows, cluster lookup through $W_4:16\times8$7 is $W_4:16\times8$8, mean comparison is $W_4:16\times8$9, and the paper reports that shape-based search reduces time by about $W_5:16\times16$0 compared to exhaustive non-shape search (Singh et al., 2013). Memory is reduced because objects are stored in the smallest adequate windows from $W_5:16\times16$1 to $W_5:16\times16$2 instead of in uniformly large templates (Singh et al., 2013).

CPU-only geometry-first systems demonstrate similar effects. aUToTrack reports an end-to-end runtime of $W_5:16\times16$3 on Intel Xeon E5-2699R CPUs, broken down as SqueezeDet $W_5:16\times16$4 on 8 cores, clustering $W_5:16\times16$5 on 1 core, and tracking $W_5:16\times16$6 on 1 core, with the complete pipeline running in less than $W_5:16\times16$7 and no GPU (Burnett et al., 2019). BOX3D measures Layer I at $W_5:16\times16$8, Layer II at $W_5:16\times16$9, and Layer III at $p(z)$0 on an Intel Core i9-12900KF when using YOLOv8n (Saucedo et al., 2024).

Representation changes can yield more dramatic savings. Visual Mesh reports $p(z)$1 for a 5-layer mesh network and $p(z)$2 for a 9-layer version on an Intel NUC7i7BNH, with the paper noting a roughly $p(z)$3 speedup over the fastest comparator tested on CPU while maintaining strong accuracy (Houliston et al., 2018). The event-camera line-segment system processes more than $p(z)$4 on $p(z)$5, with detection at $p(z)$6 and tracking at $p(z)$7 in that resolution, and even higher rates at $p(z)$8 (Ikura et al., 8 Oct 2025). The BEV indoor-navigation system reports that YOLO-640 and Hough are well below $p(z)$9 end-to-end on Raspberry Pi 5, while YOLO-1024 is reported as just over $p(z_i\mid z_j)$0 end-to-end, with detector cost dominating and local/global fusion negligible (Li et al., 20 Mar 2026).

Hardware-aware design introduces additional efficiency levers. LiFT is organized around a conservative upper bound of $p(z_i\mid z_j)$1 for real-time FPGA deployment and achieves $p(z_i\mid z_j)$2 under INT8, sparse, 2D pillar-based processing (Lis et al., 19 Jan 2025). The move from 3D voxels to 2D pillars is justified by an illustrative Im2Col buffering comparison of $p(z_i\mid z_j)$3 cells for a dense 3D tensor versus $p(z_i\mid z_j)$4 cells for a 2D tensor (Lis et al., 19 Jan 2025). VINet shifts the system-level perspective further: under holistic cooperative perception with 10 perception nodes, it reports approximately $p(z_i\mid z_j)$5 system-level computational cost reduction and approximately $p(z_i\mid z_j)$6 system-level communication cost reduction relative to early or dense fusion baselines, while keeping only a lightweight feature extractor on slave nodes and centralizing the heavy BEV backbone once at the CCU (Bai et al., 2022).

There is, however, no single efficiency formula that spans all systems. A plausible interpretation is that lightweightness is obtained by moving the main computational bottleneck into whichever structure is sparsest and most semantically aligned with the environment: shape windows, event blocks, active pillars, cluster centroids, or global-frame pillar indices.

5. Modalities, application domains, and deployment patterns

The application space of lightweight geometric detection systems is unusually broad because the approach is tied less to a particular sensor than to a style of inference. Assistive perception for visually impaired users is one clear example. The shape-based system is designed as an in-house audio aid that takes scene images from a Wi‑Fi camera and returns Bluetooth or speaker alerts whose urgency depends on object severity, such as snake, broken glass, chair, or table (Singh et al., 2013). The user interface is a palm-sized remote with five functions, including detection initiation, object reporting, training for beginners, difficulty alerts, and a home function (Singh et al., 2013).

Autonomous driving and robotics form a second major domain. aUToTrack estimates 3D positions and velocities for pedestrians, cyclists, and cars using monocular vision, LiDAR, and GPS/IMU, and reports KITTI test-set performance of MOTA $p(z_i\mid z_j)$7, MOTP $p(z_i\mid z_j)$8, MT $p(z_i\mid z_j)$9, ML $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$0, IDS $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$1, FRAG $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$2, and FPS $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$3 for cars (Burnett et al., 2019). BOX3D addresses local 3D object detection and global localization through a three-layer camera–LiDAR fusion stack on KITTI, with mIoU depending on the underlying YOLOv8 model size (Saucedo et al., 2024). VINet targets cooperative 3D object detection over a large vehicle–infrastructure network, with roadside and vehicle LiDARs transformed into a shared global frame and fused through a two-stream architecture (Bai et al., 2022).

Industrial, subterranean, and structurally degraded environments motivate another deployment pattern. The radar framework is evaluated in a dust-filled enclosed trailer and in underground mining tunnels, where camera and LiDAR degrade severely while 4D mmWave radar remains stable (Liu et al., 19 Jan 2026). In a $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$4-frame two-person sequence in the trailer, the radar detector achieves frame-wise recall of $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$5 $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$6 versus $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$7 $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$8 for the camera detector, with person-count recall $$I(x)=c\exp\!\left(-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)\right)+d,$$9 $\mu$0 versus $\mu$1 $\mu$2 (Liu et al., 19 Jan 2026). The indoor structural-detection system is directed at mapping and navigation in corridors, classrooms, garages, and cluttered laboratories on a low-power SBC (Li et al., 20 Mar 2026).

Remote sensing and aerial imagery introduce a different geometric emphasis. LO-Det is a lightweight oriented object detector for remote sensing images, combining CSA-DRF for efficient neck design and DSC-Head for stable oriented-box prediction without explicit angle regression (Huang et al., 2022). On DIOR at input size $\mu$3, LO-Det reports mAP $\mu$4, $\mu$5 fps on RTX 3090, $\mu$6 model size, and $\mu$7; on DOTA at $\mu$8, it reports mAP $\mu$9 and the same model size (Huang et al., 2022).

Edge-based front ends for SLAM and event cameras extend the same principle to structure-first perception. LC and LCS aim to suppress overconfidence and high computation in landmark-rich scenes by using trust factors, ignorance regions, and layered grouping rather than large databases or full covariance tracking (Tafrishi et al., 2017, Tafrishi et al., 2020). The event-only line-segment system addresses high-resolution event cameras without auxiliary frames and maintains real-time operation using only local lattice buffers and endpoint perturbation tracking (Ikura et al., 8 Oct 2025).

This diversity shows that lightweight geometric detection is not limited to low-end hardware. It is equally a deployment strategy for environments where modality failure, communication cost, or interpretability constraints make geometry preferable to dense learned representations.

6. Robustness, limitations, and comparative tensions

The principal strength of lightweight geometric detection systems is that robustness often derives from physically interpretable constraints rather than from latent feature invariance alone. Radar filtering by angular bounds, bounded RCS, and Doppler plausibility explicitly suppresses metallic multipath and non-physical returns (Liu et al., 19 Jan 2026). Binary preprocessing and coarse geometry in the assistive detector reduce sensitivity to background clutter, although illumination robustness is not fully detailed (Singh et al., 2013). Visual Mesh is robust to scale because its sampling density over the object is approximately constant with distance (Houliston et al., 2018). The event-camera pipeline avoids the velocity bias of time-window accumulation because event lifetime in a block is measured in events rather than in wall-clock time (Ikura et al., 8 Oct 2025).

At the same time, the limitations are also geometric and usually transparent. Shape-based clustering can fail when many categories share the same coarse geometry, as when rectangle covers many devices in the assistive detector (Singh et al., 2013). Mean-of-cluster comparison can misclassify when intra-cluster variance is high, and early rejection of unseen shapes saves computation but may miss detections (Singh et al., 2013). In the radar framework, sparse anisotropic returns can fragment clusters, and heuristic thresholds are scenario-dependent (Liu et al., 19 Jan 2026). aUToTrack notes that car centroid estimation can be biased toward the LiDAR-facing surface by about $\Sigma$0 in crowded or complex scenes (Burnett et al., 2019). The indoor BEV structural detector observes that Hough and LSD are fast but degrade strongly in clutter, and that LSD in particular produces excessive segment fragmentation leading to backend congestion (Li et al., 20 Mar 2026).

A recurring comparative tension concerns deep learning. Several papers position lightweight geometric systems against heavy learned detectors, but the opposition is not absolute. aUToTrack uses a single-stage CNN only for 2D box proposals and leaves 3D localization geometric (Burnett et al., 2019). BOX3D similarly relies on YOLOv8 masks and boxes yet keeps the rest of the stack geometric (Saucedo et al., 2024). The BEV indoor-navigation work finds that YOLOv8n-OBB, when applied after 3D-to-2D BEV projection, achieves the best robustness–efficiency balance among tested methods on the Raspberry Pi 5, outperforming purely classical detectors in clutter while remaining CPU-feasible (Li et al., 20 Mar 2026). CSL-YOLO and LO-Det show that lightweight learned detectors themselves can be interpreted as geometry-aware when they preserve spatial modeling capacity through depthwise operations, oriented boxes, or scale-aware neck design (Zhang et al., 2021, Huang et al., 2022).

This suggests a misconception worth correcting: lightweight geometric detection is not synonymous with training-free detection. Some systems are entirely model-driven; others combine a minimal learned front end with predominantly geometric downstream reasoning; still others use learned modules whose design remains explicitly geometry-centric. The distinguishing property is not the absence of learning, but the primacy of geometric structure in controlling computation and decision flow.

7. Research directions and open problems

Several papers explicitly identify extensions that would preserve the lightweight rationale while improving discrimination. The shape-based assistive detector proposes enriching the feature set with Hu moments $\Sigma$1, Zernike or Fourier descriptors, adaptive thresholds $\Sigma$2, incremental cluster split/merge strategies, multi-scale pyramids with early exits using DoG extrema counts, and fusion of color or texture cues where available (Singh et al., 2013). The geometric-codebook framework proposes combining geometric features with complementary appearance features within the same hierarchical codebook and continuing online generative–discriminative learning under weak supervision (Prasad, 2013).

Hardware-driven work suggests another direction: keep geometry and sparsity, but improve expressivity. LiFT points to Spatially-Dilated Sparse Convolutions, mixed precision, and adaptive pillar grids for long-range scenes while retaining its FPGA-tailored design constraints (Lis et al., 19 Jan 2025). VINet indicates that stream-specific feature extraction and centralized global-frame fusion can be extended to further heterogeneous sensor sets, with camera BEV homography already described as an optional route for image features (Bai et al., 2022). The event-based line-segment system proposes clustering local segments into stronger lines or planes and incorporating polarity or simple timestamp gating into its score while keeping the event-only, local-buffer design (Ikura et al., 8 Oct 2025).

A separate direction concerns structured geometry beyond individual objects. The BEV indoor-navigation work already closes walls into watertight floorplans through Manhattan-world optimization (Li et al., 20 Mar 2026). LCS treats edges, circles, and rectangles as increasingly abstract scene entities and uses higher-level layers to suppress lower-level ambiguity (Tafrishi et al., 2020). A plausible implication is that future lightweight geometric detection systems may merge object detection, structural mapping, and scene graph construction into a single hierarchy, provided the representation remains sparse enough to preserve the computational advantages that motivate the approach.

The field’s enduring challenge is therefore not whether geometry can replace learned representations in general. It is how far explicit geometry, sparse intermediate structure, and minimal learned components can be pushed before the complexity saved at inference is outweighed by the ambiguity introduced by coarse priors. The surveyed work shows that, across modalities as different as binary shapes, LiDAR pillars, 4D radar clusters, event buffers, and cooperative BEV maps, that frontier remains technically productive and practically relevant (Singh et al., 2013, Liu et al., 19 Jan 2026, Saucedo et al., 2024).