OctVox: Compact Octo-Voxel Mapping

• OctVox is a compact octo-voxel map representation that supports real-time LiDAR-Inertial Odometry with strict point density control.
• It uses a sparse, hash-based voxel grid subdivided into eight subvoxels to achieve constant-time access and effective incremental denoising.
• Integration with Heuristic-guided KNN accelerates correspondence search, reducing memory usage while boosting overall mapping performance.

OctVox is a compact octo-voxel–based map representation introduced in the Super-LIO system for LiDAR-Inertial Odometry (LIO). Designed for robust and efficient mapping in autonomous platforms with limited computational and memory resources, OctVox implements a strict density control mechanism and incremental denoising, facilitating real-time, resource-aware LIO solutions while maintaining competitive accuracy and robustness across diverse environments (Wang et al., 6 Sep 2025).

1. Data Structure and Octant Subdivision

The core of OctVox is a sparse, hash-based voxel grid, wherein the global map $\mathcal{M}$ is implemented with a Robin-Hood–hashed table storing fixed-size voxels $V_i$, each with edge length $r_v$. Every voxel is subdivided into eight contiguous subvoxels $V_{i,s}$, $s\in\{0,…,7\}$, with each subvoxel having edge length $r_s = r_v/2$.

Each subvoxel stores a single representative:

• $\mu_{i,s} \in \mathbb{R}^3$: the incrementally averaged centroid
• $n_{i,s} \in \mathbb{N}$: the count of fused points

Logical occupancy is given by $o_{i,s} = 1$ if $n_{i,s} > 0$, else $V_i$0. The local covariance is approximated as $V_i$1, reflecting the noise reduction from averaging.

Subvoxel indexing uses $V_i$2 bitwise operations:

• Compute $V_i$3
• Parent voxel index: $V_i$4 (integer division by 2)
• Subvoxel index: $V_i$5, $V_i$6

This structure ensures constant-time access to both voxel and subvoxel, independent of map size.

2. Point Density Control and Incremental Denoising

OctVox’s 2×2×2 subvoxel subdivision limits each voxel to eight representatives, strictly bounding per-voxel point density and preventing memory blow-up.

When inserting a new point $V_i$7:

• If slot $V_i$8 is empty: initialize $V_i$9, $r_v$0
• Else if $r_v$1 and $r_v$2:

$r_v$3

• Otherwise, the point is discarded (treated as an outlier)

The merge threshold $r_v$4 (typically $r_v$5 of the sensor) maintains outlier robustness. Averaging incrementally reduces variance proportional to $r_v$6, providing online denoising as the map is updated.

3. Map-Update Operations and O(1) Mechanics

OctVox map fusion per LiDAR point proceeds as follows:

• Index to voxel/subvoxel $r_v$7 in $r_v$8
• If subvoxel is empty, initialize; if within $r_v$9, update as above; else, discard
• There is no dynamic splitting beyond the fixed $V_{i,s}$0 subdivision

Occupancy (per subvoxel) can be defined by $V_{i,s}$1 or normalized count $V_{i,s}$2. All per-point update operations are constant time, yielding $V_{i,s}$3 frame update complexity for $V_{i,s}$4 points.

4. Memory and Runtime Efficiency

OctVox achieves a significant reduction in memory footprint relative to alternatives. Each subvoxel stores one $V_{i,s}$5 (float[3]) and $V_{i,s}$6 (int), for $V_{i,s}$7 B, totaling $V_{i,s}$8 B per voxel (plus $V_{i,s}$9 B hash-table overhead). By comparison, a raw-point hashed voxel storing $s\in\{0,…,7\}$0 points at $s\in\{0,…,7\}$1 B/point would require approximately $s\in\{0,…,7\}$2 B (e.g., $s\in\{0,…,7\}$3 B/voxel).

Empirical runtime metrics (Wang et al., 6 Sep 2025):

Platform	Avg Frame Time	CPU Usage
X86 (5800H@5×)	$s\in\{0,…,7\}$4 ms	$s\in\{0,…,7\}$533.5 %
ARM (Orin NX@1×)	$s\in\{0,…,7\}$6 ms	$s\in\{0,…,7\}$737.8 %

Relative to FAST-LIO2, Super-LIO with OctVox is $s\in\{0,…,7\}$8 faster (x86) and $s\in\{0,…,7\}$9 faster (ARM), using $r_s = r_v/2$0–$r_s = r_v/2$1 less CPU.

5. Pipeline Integration and Heuristic-Guided KNN (HKNN)

In Super-LIO’s LIO pipeline, OctVox underlies both map storage and the correspondence search. The scan-to-map matching pipeline comprises:

1. IMU-aided de-skewing of LiDAR scans to obtain $r_s = r_v/2$2
2. Transformation of $r_s = r_v/2$3 to the world frame to yield $r_s = r_v/2$4
3. Center-based downsampling
4. For each $r_s = r_v/2$5, Heuristic-guided KNN (HKNN) within OctVox to retrieve $r_s = r_v/2$6 nearest subvoxel centroids
5. Local plane fitting via PCA on $r_s = r_v/2$7 points, forming point-to-plane residuals
6. IESKF state update with residuals
7. Map update via downsampled point re-insertion into OctVox

The HKNN algorithm precomputes a canonical traversal list $r_s = r_v/2$8 grouping subvoxels by increasing minimum distances $r_s = r_v/2$9. Octant symmetry is exploited for efficient traversal using bitwise XOR and sign flips. Groups are traversed in ascending $\mu_{i,s} \in \mathbb{R}^3$0, with a $\mu_{i,s} \in \mathbb{R}^3$1-size max-heap for the nearest neighbors and early termination when the next group’s $\mu_{i,s} \in \mathbb{R}^3$2 lower bound exceeds the worst in the heap, reducing the number of distance computations.

6. Empirical Evaluation and Comparative Analysis

Evaluation on four public LIO datasets (M2DGR, NCLT, MCD, NTU) and several self-collected sequences demonstrates OctVox’s effectiveness:

• Super-LIO achieves an average RMSE of $\mu_{i,s} \in \mathbb{R}^3$3 m, compared to $\mu_{i,s} \in \mathbb{R}^3$4 m (FAST-LIO2), $\mu_{i,s} \in \mathbb{R}^3$5 m (Faster-LIO), and $\mu_{i,s} \in \mathbb{R}^3$6 m (iG-LIO)
• Real-time performance maintained on ARM platforms, with stable tracking in narrow indoor, UAV, and fast-motion scenarios

OctVox offers:

• $\mu_{i,s} \in \mathbb{R}^3$7–$\mu_{i,s} \in \mathbb{R}^3$8 lower memory per voxel and $\mu_{i,s} \in \mathbb{R}^3$9–$n_{i,s} \in \mathbb{N}$0 faster KNN than raw-point hashing
• $n_{i,s} \in \mathbb{N}$1 updates (vs $n_{i,s} \in \mathbb{N}$2 for iKD-tree), yielding improved cache efficiency on ARM
• Greater floating-point robustness and avoidance of expensive matrix inversions compared to probabilistic-voxel approaches (e.g., iG-LIO)

Summarily, OctVox is a rigorously engineered compromise between raw-point fidelity and full Gaussian models, delivering strict point density control, incremental denoising, and constant-time insertions. Coupled with HKNN, these features establish OctVox as a leading memory- and runtime–efficient backbone for modern LiDAR-inertial odometry systems, with demonstrated robustness and accuracy across heterogeneous deployment scenarios (Wang et al., 6 Sep 2025).