---
title: 'Super-LIO: Efficient LiDAR-Inertial Odometry'
url: https://www.emergentmind.com/topics/super-lio
type: topic
---

# Super-LIO: Efficient LiDAR-Inertial Odometry

Super-LIO is a robust and efficient LiDAR-Inertial Odometry (LIO) system designed for high performance and accuracy on resource-constrained platforms such as aerial robots and mobile autonomous systems. Central to Super-LIO is the OctVox map structure—a compact octo-voxel-based approach enforcing strict spatial density constraints—paired with a heuristic-guided KNN (HKNN) strategy for rapid correspondence search. These innovations produce significant runtime and memory efficiency while maintaining competitive or superior odometric accuracy compared to contemporary LIO systems. Super-LIO integrates smoothly with standard LIO pipelines, is open-source, and demonstrates platform compatibility across X86 and ARM architectures [2509.05723].

## 1. System Architecture and Processing Pipeline

Super-LIO employs a tightly coupled LiDAR–IMU odometry scheme based on the iterated error-state Kalman filter (IESKF). The real-time odometry update loop comprises four major stages:

1. **IMU Propagation**: At high rate, the filter reads IMU samples $(\mathbf{a}_k, \boldsymbol\omega_k)$ and applies midpoint integration to compute the propagated state $\hat{\mathbf X}_t^-$ and covariance $\mathbf P_t^-$.

2. **LiDAR Preprocessing**: For each scan, raw points $\mathbf p_i^{\mathcal L}$ undergo de-skewing relative to IMU poses at the scan anchor time $t_k$:
   $$
   \mathbf p_i^{\mathcal I_k} = \mathbf R_{\mathcal I_i}^{\mathcal I_k} \left( \mathbf R_{\mathcal L}^{\mathcal I} \mathbf p_i^{\mathcal L} + \mathbf p_{\mathcal L}^{\mathcal I} \right) + \mathbf p_{\mathcal I_i}^{\mathcal I_k}
   $$
   The preprocessed scan is further downsampled using a center-based filter to ensure uniform spatial coverage.

3. **Odometry Estimation (Scan-to-Map)**: Each downsampled point $\mathbf p_j^{\mathcal I_k}$ is transformed to the world frame:
   $$
   \mathbf p_j^{\mathcal G} = \mathbf R_{\mathcal I}^{\mathcal G}(t_k)\, \mathbf p_j^{\mathcal I_k} + \mathbf p_{\mathcal I}^{\mathcal G}(t_k)
   $$
   For each such point:
   - $K$ nearest neighbors are retrieved from the OctVox map via HKNN.
   - Principal Component Analysis (PCA) fits a local plane.
   - A point-to-plane residual $r_j = \mathbf n^\top (\mathbf p_j^{\mathcal G} - \bar{\mathbf p})$ is computed.

   The residuals are stacked and used in the IESKF observation update to yield the posterior state $\hat{\mathbf X}_{t_k}^+$.

4. **Map Update**: Each de-skewed, world-frame point is inserted into the OctVox map for incremental averaging and noise suppression.

A condensed per-frame processing pseudocode illustrates this loop:

```plaintext
loop:
  read IMU → propagate IESKF
  if new LiDAR frame:
    deskew all points via IMU states
    downsample points
    H ← empty residual list
    for each point pᵢ:
      pᵢʷ ← transform(pᵢ, prior_state)
      Nᵢ ← HKNN(pᵢʷ, OctVox, K, R)
      (nᵢ, ȳᵢ) ← PCA_plane(Nᵢ)
      rᵢ ← nᵢᵀ (pᵢʷ − ȳᵢ)
      H.append((rᵢ, Jacobianᵢ))
    update IESKF with H → posterior_state
    for each original point:
      OctVox.insert(point)
```

## 2. OctVox Map: Data Structure and Denoising

OctVox represents the global map as a sparse hash table of voxels $\mathcal V_{\mathbf k}$ (edge length $r_v$), each subdivided into eight subvoxels of size $r_s = \frac12 r_v$. Every subvoxel $\mathcal V_{\mathbf k,s}$ maintains:

- An accumulated mean $\boldsymbol\mu_{\mathbf k,s} \in \mathbb R^3$
- A counter $n_{\mathbf k,s}$ capped at $n_{\max} = 8$

Point-to-voxel and subvoxel indexing for each world-frame point employs bitwise and arithmetic operations to maintain constant O(1) time complexity.

**Incremental Fusion and Density Control:**  
On insertion, if a subvoxel is empty, it is initialized with $(\mathbf p, 1)$. If occupied and $\|\mathbf p - \boldsymbol\mu\| \le \tau_{\rm merge}$ and $n < n_{\max}$, an incremental mean is computed:
$$
\boldsymbol\mu \leftarrow \boldsymbol\mu + \frac{1}{n+1} (\mathbf p - \boldsymbol\mu), \quad n \leftarrow n + 1
$$
Otherwise, the point is dropped, enforcing a strict density and providing per-subvoxel denoising, with statistical variance decaying as $1/n$.

The following pseudocode summarizes this operation:

```plaintext
function OctVox.insert( p : R³ ):
  (k,s) ← subvoxel_index(p)
  entry ← hash_map.lookup_or_alloc(k)
  (μ,n) ← entry.subvoxel[s]
  if n==0:
    entry.subvoxel[s] ← (p,1)
  else if ‖p−μ‖≤τ_merge and n<n_max:
    μ ← μ + (p−μ)/(n+1)
    n ← n+1
    entry.subvoxel[s] ← (μ,n)
  else:
    // drop point (density cap or outlier)
end
```

**Efficiency**: Each insertion has an expected O(1) complexity due to the hash structure [2509.05723].

## 3. Heuristic-Guided KNN (HKNN) Search

The HKNN module accelerates the nearest-neighbor correspondence crucial for scan-to-map alignment. HKNN operates via two phases:

**Precomputation**:  
- Defines a canonical origin subvoxel.
- Enumerates all candidate subvoxels inside a maximum radius $R_{\max}$.
- Computes minimal Euclidean distances $d_{i,j}$ across all subvoxel pairs and groups them as $\mathcal H_m$, sorted in ascending order to create a traversal list $\mathcal T$.

**Runtime Query**:  
- For each transformed query point:
  - Computes its parent voxel/subvoxel.
  - Iteratively explores the sorted subvoxel groups up to the pre-set search radius, leveraging octant symmetry for efficient candidate indexing.
  - Maintains a max-heap of size $K$ for minimal distance subvoxel means.

Pseudocode excerpt:
```plaintext
function HKNN(p_I, prior_state, OctVox, T, D, R, K):
  p_G ← transform(p_I, prior_state)
  (k_p,s_p) ← subvoxel_index(p_G)
  m* ← max{ m | d_m ≤ R }
  H ← empty max‐heap(capacity=K)
  for i=0…m*:
    if |H|=K and d_i > worst_dist(H): break
    for (k_off,s) in H_i:
      (σx,σy,σz) ← octant_bits(s_p)
      k′ ← k_p + (σx k_off.x, σy k_off.y, σz k_off.z)
      s′ ← s ⊕ s_p
      if OctVox.has(k′,s′):
        μ ← OctVox.get_mean(k′,s′)
        δ ← ‖p_G−μ‖
        if δ≤R:
          if |H|<K or δ<worst_dist(H):
            H.push_or_replace((δ,μ))
  return sort_ascending(H)
end
```

**Complexity**: HKNN inspects subvoxel groups by increasing shell distance and breaks early if no closer points can be found. In practice, it examines orders of magnitude fewer entries than standard approaches (≪ $(R/r_v)^3$), resulting in near-O(1) empirical query time.

## 4. Integration with LiDAR-Inertial Odometry Frameworks

Super-LIO is designed for seamless integration with existing error-state Kalman filter-based LIO systems. Key modifications include:

- Substituting the traditional raw-point or KD-tree map container with the OctVox hash-voxel structure.
- Replacing the generic KNN search algorithm with HKNN for point-to-map correspondence.
- Adopting center-based downsampling as the primary LiDAR preprocessing step to optimally feed the OctVox structure.
- Maintaining identical observation models and filter mathematics (such as point-to-plane constraints in IESKF).
- Retaining all IMU propagation logic (IESKF or IEKF).

Parameters related to voxel size, density thresholds ($\tau_{\rm merge}$), neighborhood size ($K$), and maximal search radius ($R_{\max}$) are exposed for tuning [2509.05723].

## 5. Experimental Evaluation

Super-LIO has been extensively assessed on both public and private datasets:

- **Public**: M2DGR (ground vehicles), NCLT (long-term outdoor), MCD (solid-state LiDAR), NTU (aerial systems)
- **Private**: 10 sequences from Livox MID360, covering diverse environments

**Metrics**: Root Mean Squared Error (RMSE), Relative Pose Error, per-frame runtime (ms), CPU load (%), memory footprint.

**Performance Summary**:

| Method         | Avg Time (ms) | CPU % |
|----------------|--------------|-------|
| Super-LIO      | 2.66         | 51    |
| Super-LIO*     | 3.05         | 65    |
| FAST-LIO2      | 9.92         | 62    |
| Faster-LIO     | 7.57         | 54    |
| iG-LIO         | 21.07        | 62    |

- Super-LIO offers a 3.7× speedup vs FAST-LIO2 and 11% lower CPU usage on x86 platforms.
- On ARM devices (Orin NX), Super-LIO achieves ∼9.4 ms per frame, 49% CPU utilization, and a 4.2× speedup over FAST-LIO2.
- Accuracy (RMSE = 0.74 m avg) matches or surpasses FAST-LIO2, Faster-LIO, iG-LIO.
- Ablation removing HKNN (Super-LIO*) yields 5–10% reduced accuracy.
- OctVox provides ∼20% smaller hash table size compared to KD-tree or iKD-tree storage; per-point map update remains strictly O(1) with no batch rebuilds.

## 6. Implementation and Open-Source Availability

Super-LIO is fully open-source and plug-and-play compatible for a range of LiDAR sensors and system platforms. The implementation is modular:

- `src/ieskf/`: IESKF filter (propagation/update)
- `src/octvox/`: OctVox mapping (subvoxel indexing, hash table methods)
- `src/hknn/`: HKNN (group precomputation and runtime query)
- `src/preprocess/`: LiDAR deskewing, center-based downsampling
- `launch/`: ROS2 launch files for various sensor configurations

System setup (Ubuntu 20.04, ROS2 Foxy) and examples:
```bash
git clone https://github.com/Liansheng-Wang/Super-LIO.git
colcon build --packages-select super_lio
source install/setup.bash
ros2 launch super_lio run_lio.launch.py lidar:=livox mid360 imu:=xsens
```
Threading and resource allocation are automatically adapted to detected CPU cores. Configuration (e.g., voxel size, merge threshold, neighborhood parameters) is provided in `cfg/params.yaml`.

Super-LIO’s OctVox and HKNN deliver a concise yet adaptable mapping and search engine, markedly enhancing efficiency on both desktop and embedded computing architectures while retaining or surpassing state-of-the-art odometric fidelity [2509.05723].

Source: https://www.emergentmind.com/topics/super-lio