---
title: 'OctVox: Compact Octo-Voxel Mapping'
url: https://www.emergentmind.com/topics/octvox
type: topic
---

# OctVox: Compact Octo-Voxel Mapping

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 [2509.05723].

## 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 $0$. The local covariance is approximated as $\Sigma_{i,s} \simeq \sigma_0^2 I / n_{i,s}$, reflecting the noise reduction from averaging.

Subvoxel indexing uses $O(1)$ bitwise operations:
- Compute $k^{sub} = \lfloor \hat p^G / r_s \rfloor \in \mathbb{Z}^3$
- Parent voxel index: $k = k^{sub} \gg 1$ (integer division by 2)
- Subvoxel index: $(b_x, b_y, b_z) = (k^{sub}_x \bmod 2, k^{sub}_y \bmod 2, k^{sub}_z \bmod 2)$, $s = b_x + 2b_y + 4b_z$

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 $\hat p^G$:
- If slot $(k,s)$ is empty: initialize $\mu_{i,s} \leftarrow \hat p^G$, $n_{i,s} \leftarrow 1$
- Else if $\|\hat p^G - \mu_{i,s}\|_2 \leq \tau_{\text{merge}}$ and $n_{i,s} < n_{\text{max}}$:
  $$
  \mu_{i,s} \leftarrow \mu_{i,s} + \frac{\hat p^G - \mu_{i,s}}{n_{i,s} + 1}, \quad n_{i,s} \leftarrow n_{i,s} + 1
  $$
- Otherwise, the point is discarded (treated as an outlier)

The merge threshold $\tau_{\text{merge}}$ (typically $3\sigma$ of the sensor) maintains outlier robustness. Averaging incrementally reduces variance proportional to $1/n_{i,s}$, 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 $(k,s)$ in $O(1)$
- If subvoxel is empty, initialize; if within $\tau_{\text{merge}}$, update as above; else, discard
- There is no dynamic splitting beyond the fixed $2\times2\times2$ subdivision

Occupancy (per subvoxel) can be defined by $p_{occ}^{new} = 1 - \exp(-\alpha\cdot n_{i,s})$ or normalized count $w_{i,s} = n_{i,s}/n_{\text{max}}$. All per-point update operations are constant time, yielding $O(N)$ frame update complexity for $N$ points.

## 4. Memory and Runtime Efficiency

OctVox achieves a significant reduction in memory footprint relative to alternatives. Each subvoxel stores one $\mu$ (float[3]) and $n$ (int), for $16$ B, totaling $128$ B per voxel (plus $\approx 16$ B hash-table overhead). By comparison, a raw-point hashed voxel storing $N$ points at $12$ B/point would require approximately $12N$ B (e.g., $N = 50 \Rightarrow 600$ B/voxel).

Empirical runtime metrics [2509.05723]:

| Platform          | Avg Frame Time          | CPU Usage      |
|-------------------|------------------------|----------------|
| X86 (5800H@5×)    | $2.66 \pm 0.96$ ms     | $\sim$33.5 %   |
| ARM (Orin NX@1×)  | $9.40 \pm 2.45$ ms     | $\sim$37.8 %   |

Relative to FAST-LIO2, Super-LIO with OctVox is $3.7\times$ faster (x86) and $4.2\times$ faster (ARM), using $\sim1.3$–$1.6\times$ 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 $p^I$
2. Transformation of $p^I$ to the world frame to yield $\hat p^G$
3. Center-based downsampling
4. For each $\hat p^G$, Heuristic-guided KNN (HKNN) within OctVox to retrieve $K$ nearest subvoxel centroids
5. Local plane fitting via PCA on $K$ 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 $\mathcal{H}_0,\ldots,\mathcal{H}_M$ grouping subvoxels by increasing minimum distances $d_m$. Octant symmetry is exploited for efficient traversal using bitwise XOR and sign flips. Groups are traversed in ascending $m$, with a $K$-size max-heap for the nearest neighbors and early termination when the next group’s $d_{m+1}$ 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 $0.74$ m, compared to $0.81$ m (FAST-LIO2), $0.83$ m (Faster-LIO), and $0.93$ m (iG-LIO)
- Real-time performance maintained on ARM platforms, with stable tracking in narrow indoor, UAV, and fast-motion scenarios

OctVox offers:
- $5$–$10\times$ lower memory per voxel and $3$–$4\times$ faster KNN than raw-point hashing
- $O(1)$ updates (vs $O(\log N)$ 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 [2509.05723].

Source: https://www.emergentmind.com/topics/octvox