C³P-VoxelMap: Compact Probabilistic Voxel Mapping

Updated 8 July 2026

The paper introduces a compact, point-free voxel representation that updates probabilistic plane uncertainty cumulatively, eliminating the need for raw historical point storage.
It leverages a locality-sensitive hash for lazy voxel merging, effectively reducing map redundancy and computational overhead in LiDAR odometry.
Experimental results show a 20% accuracy boost, 20% faster performance, and 70% lower memory consumption compared to state-of-the-art methods.

C³P-VoxelMap denotes a compact, cumulative and coalescible probabilistic voxel mapping method for direct LiDAR odometry that was introduced to improve performance, accuracy and memory efficiency while preserving the probabilistic plane modeling associated with VoxelMap-style registration (Yang et al., 2024). Its central claim is that probabilistic voxel mapping had previously required storing past point clouds and re-iterating on them to update planar uncertainty, which consumed large memory space and CPU cycles. C³P-VoxelMap addresses that cost with a point-free voxel representation based on fixed sufficient statistics, then further reduces map redundancy by lazily merging voxels that likely belong to the same physical plane through a locality-sensitive hash (Yang et al., 2024).

1. Problem formulation and nomenclature

C³P-VoxelMap is situated in the setting of voxel-based LiDAR odometry, in which 3D space is partitioned into voxels and each voxel stores a local geometric model, often a plane. Incoming scan points are associated with voxels in the map, and the pose is optimized so points align with the local voxel planes. In the probabilistic variant of this paradigm, a voxel plane is represented not only by its geometry but also by an uncertainty model reflecting LiDAR measurement noise and pose estimation noise of points transformed into the world frame (Yang et al., 2024).

The method’s title terms are definitional rather than rhetorical. Compact means that each voxel stores only a fixed set of sufficient statistics rather than raw historical points. Cumulative means that voxel plane parameters and their uncertainty can be updated recursively when new points arrive, without revisiting past points. Coalescible means that different voxels that likely correspond to the same physical plane can be merged so that the map adapts to structures such as walls, floors, and ceilings (Yang et al., 2024).

Term	Meaning	Mechanism
Compact	Fixed storage per voxel	Point-free sufficient statistics
Cumulative	Recursive update without revisiting past points	Updates of $\mathbf{q}$ , $\mathbf{A}$ , and uncertainty statistics
Coalescible	Merge voxels on the same physical plane	Lazy locality-sensitive hash triggering

The motivation is explicitly computational. Prior probabilistic voxel mapping is described as non-cumulative probabilistic updating with time complexity $O(MN)$ and space complexity $O(N)$ , where $N$ is the number of points in a voxel and $M$ is the number of update iterations. C³P-VoxelMap replaces this with constant per-voxel storage and cumulative statistics, changing update behavior to $O(N)$ total over $N$ points and per-voxel storage to $O(1)$ (Yang et al., 2024).

A common misunderstanding is to treat C³P-VoxelMap as a new state estimator. The paper instead states that the state estimation algorithm remains the same as prior IESKF-based methods, especially VoxelMap/Fast-LIO2; the novelty lies in map representation and map management rather than in a new filtering architecture (Yang et al., 2024).

2. Probabilistic voxel representation

Each voxel in C³P-VoxelMap represents a local planar feature using a plane normal $\mathbf{n}$ , a center point $\mathbf{A}$ 0, a covariance matrix for plane uncertainty, and a fixed set of sufficient statistics that support cumulative update. The method follows the probabilistic plane representation of VoxelMap, with a joint covariance partitioned as

$\mathbf{A}$ 1

This representation makes the plane itself a random object rather than a deterministic least-squares fit (Yang et al., 2024).

Given points $\mathbf{A}$ 2 in a voxel, the paper defines the voxel mean and covariance as

$\mathbf{A}$ 3

An eigendecomposition is then applied: $\mathbf{A}$ 4 with eigenvalues ordered as

$\mathbf{A}$ 5

The plane normal is the minor principal direction,

$\mathbf{A}$ 6

This is the local PCA plane model used throughout the method (Yang et al., 2024).

Point uncertainty enters through a first-order perturbation model. Each point is treated as $\mathbf{A}$ 7, with zero-mean Gaussian noise and covariance $\mathbf{A}$ 8. The plane parameters are then linearized as

$\mathbf{A}$ 9

leading to

$O(MN)$ 0

The Jacobians are given as

$O(MN)$ 1

with

$O(MN)$ 2

These formulas are inherited from first-order perturbation analysis of PCA plane fitting (Yang et al., 2024).

The representation is termed point-free because the original point set and per-point covariances are not retained after their information has been absorbed into sufficient statistics. This does not mean that no points were used; rather, it means that the map no longer stores them after accumulation (Yang et al., 2024).

3. Compact cumulative uncertainty update

The central technical contribution of C³P-VoxelMap is the derivation of cumulative updates for probabilistic voxel planes without retaining historical points. For geometric moments, when a new point $O(MN)$ 3 arrives in a voxel with current count $O(MN)$ 4, mean $O(MN)$ 5, and covariance matrix $O(MN)$ 6, the updated mean is

$O(MN)$ 7

and the updated covariance matrix is

$O(MN)$ 8

The new normal $O(MN)$ 9 is then obtained as the third singular vector of $O(N)$ 0 (Yang et al., 2024).

The difficulty is not the recursive update of $O(N)$ 1 or $O(N)$ 2, but the recursive update of plane uncertainty. In the original probabilistic formulation,

$O(N)$ 3

the Jacobians depend on the current mean $O(N)$ 4, the current eigensystem $O(N)$ 5, and each historical point $O(N)$ 6. C³P-VoxelMap resolves this by rewriting the covariance so that all point-dependent terms can be accumulated once into fixed statistics (Yang et al., 2024).

The sufficient statistics are

$O(N)$ 7

$O(N)$ 8

$O(N)$ 9

Here $N$ 0 are the standard basis vectors in $N$ 1. Rather than storing all $N$ 2 and $N$ 3, the voxel stores these accumulators together with $N$ 4, $N$ 5, and $N$ 6 (Yang et al., 2024).

For the normal covariance block, the paper gives

$N$ 7

where the entries of $N$ 8 are

$N$ 9

A key rewritten term is

$M$ 0

which makes explicit that the point-dependent content can be carried entirely by $M$ 1. The paper states that all covariance blocks can be reconstructed from $M$ 2, $M$ 3, and $M$ 4 plus the current PCA state (Yang et al., 2024).

The compactness claim is quantified. A symmetric $M$ 5 matrix stores 6 scalars, an asymmetric $M$ 6 matrix stores 9, there are 6 distinct $M$ 7 matrices if symmetry is exploited, 3 matrices $M$ 8, and 1 symmetric $M$ 9. The total is

$O(N)$ 0

Thus the uncertainty of a probabilistic plane can be represented by 69 scalars, independent of the number of points in the voxel (Yang et al., 2024).

This cumulative reformulation is presented as the reason the method reduces runtime complexity from $O(N)$ 1 to $O(N)$ 2 and space complexity from $O(N)$ 3 to $O(N)$ 4 (Yang et al., 2024).

4. Coalescing planar structure

The second major component of C³P-VoxelMap is voxel coalescing. Regular voxel maps split large physical planes into many separate local estimates, which increases memory use and produces noisy inter-voxel variation. C³P-VoxelMap addresses this by merging voxels that likely belong to the same physical plane, with the explicit aim of both reducing redundancy and improving map quality through cross-voxel denoising (Yang et al., 2024).

The method does not scan the entire map continuously for merge candidates. Instead, it uses a locality-sensitive hash on plane descriptors and triggers merging only when a bucket has accumulated enough likely candidates. A plane is parameterized by spherical coordinates of the normal, $O(N)$ 5 and $O(N)$ 6, together with the signed offset

$O(N)$ 7

Because $O(N)$ 8 alone cannot distinguish distant but similar planes, the paper also introduces in-plane locality coordinates $O(N)$ 9. Using

$N$ 0

the in-plane coordinates are

$N$ 1

The resulting 5D quantized key is

$N$ 2

Voxels with similar orientation, offset, and in-plane locality hash into the same bucket (Yang et al., 2024).

When a bucket accumulates enough voxels, a merge operation is triggered. The paper states that the voxel with the most points is selected as the reference, because a voxel with more points has lower plane uncertainty. Candidate voxels are then tested against a planarity criterion based on the covariance eigenvalues: $N$ 3 where $N$ 4 is a small threshold near zero (Yang et al., 2024).

Once a voxel is merged into the reference, the merged voxel’s own parameters $N$ 5, $N$ 6, and $N$ 7 are released, and future points falling into that voxel update the reference voxel cumulatively. For the merged moments of two point sets $N$ 8 and $N$ 9, with sizes $O(1)$ 0 and $O(1)$ 1, means $O(1)$ 2, and covariances $O(1)$ 3, the paper gives

$O(1)$ 4

$O(1)$ 5

Since $O(1)$ 6, $O(1)$ 7, and $O(1)$ 8 are accumulators, a plausible implication is that their merged values follow by addition; the paper states this principle for the accumulated statistics but does not box those equations explicitly (Yang et al., 2024).

This merge strategy differs materially from the union-find plane-merging design of "VoxelMap++" (Yuan et al., 2023). VoxelMap++ stores one plane feature with a 3DOF representation per voxel and merges kid planes into father planes incrementally through covariance-aware coplanarity tests and union-find (Yuan et al., 2023). C³P-VoxelMap, by contrast, preserves VoxelMap-style probabilistic planes and performs lazy merging through a locality-sensitive hash, with bucket-triggered coalescing rather than constant scanning (Yang et al., 2024).

5. Odometry integration and position within the VoxelMap lineage

C³P-VoxelMap is integrated into a direct LiDAR odometry pipeline whose estimation backbone remains the Iterative Error State Kalman Filter (IESKF) used in prior systems. The paper states that incoming scan points are transformed using the current pose estimate, associated to voxel planes directly by hashing into the voxel map, used in probabilistic plane residuals for IESKF state update, and then inserted to update or create voxels in the map (Yang et al., 2024).

The probabilistic side of this formulation is clarified in the derivation note "On the Derivation of Tightly-Coupled LiDAR-Inertial Odometry with VoxelMap" (Zhan, 16 Mar 2026). That note formalizes a VoxelMap-based tightly-coupled LIO system in which each voxel maintains one probabilistic plane feature, LiDAR points are matched through point-to-plane residuals, and the residuals are fused directly inside an IESKF rather than through a loosely coupled LiDAR odometry estimate (Zhan, 16 Mar 2026). C³P-VoxelMap does not replace that estimator; it changes the map representation so that the probabilistic plane model becomes compact and cumulative (Yang et al., 2024).

The paper explicitly attributes part of its runtime advantage to direct voxel-plane lookup. It notes a runtime advantage over k-d-tree methods and approximate NNS voxel methods because no nearest-neighbor search is needed in the same way and each voxel directly stores a plane (Yang et al., 2024). This places C³P-VoxelMap within a broader evolution of voxel-based registration systems that use per-voxel geometric primitives instead of raw point neighborhoods at query time.

Within the VoxelMap lineage, the method can be summarized as follows. VoxelMap supplied the probabilistic voxel-plane idea but required historical point storage and re-iteration. VoxelMap++ added mergeable coplanar plane processing across voxels, using a union-find structure and a 3DOF plane representation (Yuan et al., 2023). C³P-VoxelMap retains the probabilistic plane representation associated with VoxelMap, makes it point-free and cumulative, and adds LSH-based lazy coalescing to reduce map size and improve denoising (Yang et al., 2024).

A common misconception is that coalescing here is merely a memory-compression device. The paper presents it as more than compression: on-demand merging is said to reduce memory footprint with minimal computational overhead and improve localization accuracy thanks to cross-voxel denoising (Yang et al., 2024).

6. Evaluation, limitations, and significance

The experimental evaluation uses KITTI odometry, UTBM, and self-collected indoor/structured data with a Livox Mid-360 solid-state LiDAR. The compared baselines are Fast-LIO2, Faster-LIO, VoxelMap, VoxelMap++, and LiTAMIN2. The reported metrics are Absolute Trajectory Error (ATE) in meters, state estimation time, map update time, total time, and memory (Yang et al., 2024).

The paper’s headline summary is that experiments exhibit 20% higher accuracy, 20% faster performance and 70% lower memory consumption than the state-of-the-art (Yang et al., 2024). The detailed tables show that on UTBM the average ATE is 11.09 for C³P-VoxelMap, compared with 13.13 for VoxelMap, 15.38 for Faster-LIO, and 14.9 for Fast-LIO2. On KITTI, the weighted average ATE is 2.74 for C³P-VoxelMap, compared with 3.95 for VoxelMap, 5.25 for Faster-LIO, 6.24 for Fast-LIO2, and 5.1 for LiTAMIN2 (Yang et al., 2024).

The timing results separate the effects of cumulative updating and merging. The average total time on KITTI is 40.43 ms for Ours (with merge), 36.97 ms for Ours (without merge), 50.84 ms for VoxelMap, 43.69 ms for Fast-LIO2, and 56.75 ms for Faster-LIO. For map update specifically, the times are 9.06 ms for Ours w/ merge, 5.38 ms for Ours w/o merge, and 17.66 ms for VoxelMap. State estimation time is 31.37 ms for Ours w/ merge and 33.18 ms for VoxelMap (Yang et al., 2024).

The memory results are a primary part of the paper’s argument. On Sequence 04, memory is 243.7 MB for C³P-VoxelMap and 521.0 MB for VoxelMap. On Sequence 06, the values are 315.9 MB and 1433.6 MB respectively. On Sequence 09, they are 878.7 MB and 2150.4 MB. In the Indoor case, the reported memory is 229.6 MB for C³P-VoxelMap, 1433.6 MB for VoxelMap, 5017.6 MB for VoxelMap++, and 292.8 MB for Faster-LIO (Yang et al., 2024). The paper also states that its memory remains constant with respect to the maximum number of voxel points $O(1)$ 9, while VoxelMap grows linearly (Yang et al., 2024).

The effective ablation structure is implicit rather than formal. Ours (without merge) isolates the cumulative point-free update and shows that it already yields major speed and memory gains over VoxelMap. Ours (with merge) adds coalescing, which slightly increases map-update overhead relative to the no-merge variant but improves accuracy and further reduces map footprint by reducing voxel count (Yang et al., 2024).

Several boundaries of the method are explicit in the text. First, the approach remains a plane-only voxel feature model; it is designed around PCA planar structure and probabilistic plane uncertainty, not a richer nonplanar local descriptor. Second, the provided text does not numerically specify the planarity threshold $\mathbf{n}$ 0, the LSH bucket widths $\mathbf{n}$ 1, or the number of voxels required to trigger a merge. Third, the exact IESKF residual equations are not restated in the paper excerpt, because the method keeps the same estimator as prior work and refers readers to VoxelMap and Fast-LIO2 for those details (Yang et al., 2024).

The broader significance of C³P-VoxelMap is therefore architectural. It demonstrates that probabilistic voxel mapping need not be point-caching, that voxel-plane uncertainty can be maintained from a constant-size summary, and that inter-voxel planar redundancy can be exploited without continuous global scanning (Yang et al., 2024). A plausible implication is that the method narrows a longstanding tradeoff in voxel-based LiDAR odometry: probabilistic modeling no longer necessarily entails linear memory growth with historical points, and map compactness no longer necessarily requires abandoning local probabilistic plane features.