Incremental k-d Tree (ikd-Tree) for Real-Time Applications

• Incremental k-d Tree (ikd-Tree) is a dynamically maintained k-d tree that supports efficient point- and box-wise updates, deletions, and spatial modifications for real-time 3D mapping.
• It uses logarithmic-time insertions and queries through incremental operations, lazy deletion, and partial subtree rebuilding to maintain balance and performance.
• Multi-threaded rebuilding and on-the-fly downsampling make the ikd-Tree ideal for applications such as LiDAR SLAM and inertial odometry, ensuring low-latency processing in dynamic environments.

The incremental k-d Tree (ikd-Tree) is a dynamically maintained k-d tree data structure optimized for environments where point data undergoes frequent online updates, deletions, and region-wise modifications. Originating in the context of real-time 3D perception workloads, particularly LiDAR–inertial odometry and simultaneous localization and mapping (SLAM), the ikd-Tree achieves efficient, logarithmic-time updates and queries through incremental operations, partial subtree rebuilding for self-balance, and multi-threaded execution. Unlike static k-d trees—where any modification triggers a complete rebuild—ikd-Tree supports point- and box-wise incremental updates, on-the-fly partial re-balancing, in-tree downsampling, and robust background rebuilding, preserving $O(\log n)$ performance for k-nearest neighbor (kNN) queries and incremental insert/delete in practical robotic and mapping pipelines (Cai et al., 2021, Xu et al., 2021, Brown, 9 Sep 2025).

1. Data Structure and Node Organization

Each ikd-Tree node retains both geometric and meta-information critical for efficient incremental operations and for supporting self-balancing heuristics:

• Core fields per node:
  • $T.\mathtt{point}$: k-dimensional point.
  • $T.\mathtt{axis}$: splitting axis, chosen by round-robin or maximal variance.
  • $T.\mathtt{leftson}, T.\mathtt{rightson}$: pointers to left/right child nodes.
  • $T.\mathtt{range}[0\dots k{-}1][0..1]$: bounding box for the subtree.
  • $T.\mathtt{treesize}$: subtree size (live + deleted nodes).
  • $T.\mathtt{invalidnum}$: count of lazy-deleted nodes in subtree.
  • $$T.\mathtt{deleted}, T.\mathtt{treedeleted}, T.\mathtt{pushdown}$$: lazy flags for deletion and propagation (Cai et al., 2021, Xu et al., 2021).

During batch construction (e.g., initialization or subtree rebuild), the axis for splitting is the dimension with largest variance in the current window, ensuring balanced partitioning. In incremental inserts, the axis is cycled modulo-dimension at each level. This strategy matches classical and contemporary dynamic k-d Tree variants (Brown, 9 Sep 2025).

2. Incremental Update and Deletion Algorithms

ikd-Tree operations are formulated to avoid global rebuilding:

• Point-wise operations:
  • Insertion: Recursively descend the tree based on $T.\mathtt{axis}$, update lazy-deletion flags, and invoke rebuilding if local balance or deletion ratios are violated.
  • Deletion/Re-insertion: Use lazy deletion—setting node flags rather than immediately restructuring—minimizing immediate restructuring cost. Logical deletes are undone via re-insertion, setting flags back to “live” (Cai et al., 2021).
• Box-wise operations:
  • Perform batch updates over an axis-aligned region $C_0$ via overlap checks on $T.\mathtt{point}$0. Full containment triggers subtree-wide flag updates; partial overlap triggers recursive descent, modifying only impacted subtrees (Cai et al., 2021, Xu et al., 2021).
• Downsampling:
  • On insertion, the tree aggregates all points lying within a cubic cell of prescribed size, keeps the one closest to the cell center, deletes the rest, and inserts the representative. This process ensures online map sparsification at the data-structure level (Cai et al., 2021, Xu et al., 2021).

The tree manages all per-node attributes (size, bounding box, deletion counts) in $T.\mathtt{point}$1 time per node during recursions via pull-up or push-down phases. All operations, inclusive of boxwise modifications and downsampling, are $T.\mathtt{point}$2 for small regions, with range search costs $T.\mathtt{point}$3 that are sub-logarithmic except in pathological cases (Cai et al., 2021, Xu et al., 2021).

3. Self-Balancing and Partial Rebuilding

Continuous streaming inserts and deletes would, in absence of control, degrade k-d tree balance. ikd-Tree introduces localized subtree repairs when one of two criteria is violated at any node $T.\mathtt{point}$4:

Criterion	Condition	Typical thresholds
$T.\mathtt{point}$5-balanced	$T.\mathtt{point}$6	$T.\mathtt{point}$7
$T.\mathtt{point}$8-deleted	$T.\mathtt{point}$9	$T.\mathtt{axis}$0

If a criterion fails, the affected subtree is “flattened” (serialized in-order, skipping logically deleted nodes), and rebuilt perfectly balanced using batch construction along axis of maximal variance (Cai et al., 2021, Xu et al., 2021, Brown, 9 Sep 2025).

The tree height is bounded as $T.\mathtt{axis}$1, enforcing logarithmic access paths for reasonable $T.\mathtt{axis}$2. Such partial rebuilding preserves overall structure elsewhere and localizes computational work.

4. Parallelization and Real-Time Execution

A distinctive feature of the ikd-Tree design is its integration of multi-threaded rebuilding to maintain real-time responsiveness:

• Main thread: Handles all inserts, deletes, re-inserts, queries, and “small” rebuilds for subtrees below size $T.\mathtt{axis}$3.
• Rebuild thread: For any triggered rebuild where subtree size exceeds $T.\mathtt{axis}$4, a background thread is spawned. The old subtree is flattened, a balanced replacement is built, and during this period updates are logged. Once built, all pending updates are applied, and subtree pointers are swapped atomically (Cai et al., 2021, Xu et al., 2021).

This double-buffering strategy guarantees concurrent query servicing from the old tree even during large rebuilds. Mutex locks ensure update consistency and no lost modifications.

5. Theoretical and Experimental Performance

ikd-Tree's complexity matches or outperforms other dynamic and static alternatives in critical metrics:

Operation	Complexity
Point insert/delete	$T.\mathtt{axis}$5
Box-wise batch insert (m)	$T.\mathtt{axis}$6
Box-wise delete	$T.\mathtt{axis}$7
Downsampling insert	$T.\mathtt{axis}$8
kNN Search (fixed $T.\mathtt{axis}$9)	$T.\mathtt{leftson}, T.\mathtt{rightson}$0
Space per node	$T.\mathtt{leftson}, T.\mathtt{rightson}$1 over static

Empirical tests on both randomized and real LiDAR SLAM workloads show $T.\mathtt{leftson}, T.\mathtt{rightson}$21.6 ms per update round versus $T.\mathtt{leftson}, T.\mathtt{rightson}$320 ms for PCL static trees, and update overheads for ikd-Tree staying near-constant even as point cloud size grows. In mapping pipelines (e.g., FAST_LIO2), ikd-Tree delivers 0.23 ms per scan update (4% of static tree rebuild times), enabling full pipelines to operate at sensor rate (100 Hz), a capability out of reach for static or naively rebuilt trees (Cai et al., 2021, Xu et al., 2021).

Comparative benchmarks against dynamic 3D structures (octree, R*-tree, nanoflann k-d tree) indicate overall best trade-off for ikd-Tree in incremental update time, kNN query efficiency, and memory management. In all tests, kNN queries remained fast and memory footprint was controlled via aggressive removal of logically deleted points during sub-tree rebuilds (Xu et al., 2021).

6. Parameter Strategies and Practical Recommendations

Optimal deployment depends on careful parameter selection:

• $T.\mathtt{leftson}, T.\mathtt{rightson}$4: Recommended in $T.\mathtt{leftson}, T.\mathtt{rightson}$5 for bounded height and infrequent rebuild triggers.
• $T.\mathtt{leftson}, T.\mathtt{rightson}$6: Set near 0.5 to reclaim memory or restructure when half a subtree's nodes are deleted.
• $T.\mathtt{leftson}, T.\mathtt{rightson}$7: Controls main-thread vs background rebuild responsibility; adjust (1,000–2,000) to available CPU and latency budget.
• Downsampling cell size: Chosen to match LiDAR noise and map resolution (0.1–0.3 m typical).
• Memory overhead: Each node requires $T.\mathtt{leftson}, T.\mathtt{rightson}$8–$T.\mathtt{leftson}, T.\mathtt{rightson}$9 static baseline, but modern hardware supports multi-million point trees (Cai et al., 2021, Xu et al., 2021).

Highly skewed insert patterns can stress balancing criteria, thereby increasing rebuild frequency. Adjusting $T.\mathtt{range}[0\dots k{-}1][0..1]$0, pre-partitioning space, or separately handling dense regions is advised.

7. Extensions, Limitations, and Broader Context

The ikd-Tree formalism has inspired extended research, including deterministic and “forest of interval” k-d trees for further amortizing rebuild costs and supporting exactness: these variants split the dataset into sub-trees and only rebuild those exceeding a specified threshold (Naim et al., 2021). However, for data volumes typical of online LiDAR SLAM and mapping, tree-forest approaches have inferior latency scaling and memory efficiency compared to directly rebalanced ikd-Trees. For ultra-high-dimensional settings, all k-d tree variants suffer from the curse of dimensionality, pointing to approximate methods as necessary alternatives (Naim et al., 2021).

Performance analyses show amortized $T.\mathtt{range}[0\dots k{-}1][0..1]$1 per operation, with total work scaling as $T.\mathtt{range}[0\dots k{-}1][0..1]$2 for typical online mapping workloads (Brown, 9 Sep 2025). Multi-threaded subtree rebuilding delivers significant speedups, particularly under non-uniform data insertion or deletion.

ikd-Tree structures are now state-of-the-art in high-rate LiDAR odometry and mapping systems (e.g., FAST-LIO2) where precise, real-time, and memory-efficient spatial query capabilities directly determine system feasibility (Xu et al., 2021). The open-source implementations and their parameterization provide a reference baseline for integrating incremental k-d trees in robotic, SLAM, and dynamic mapping frameworks.