TSDF Extraction: Methods and Applications

• TSDF Extraction is a volumetric method encoding signed distances to surfaces, truncated for efficient 3D scene mapping.
• It employs ray marching, weighted fusion, and GPU/CPU optimizations to achieve high accuracy and fast runtime performance.
• Hybrid data structures and compression strategies enable scalable, real-time mapping in robotic navigation and SLAM applications.

A Truncated Signed Distance Field (TSDF) is a volumetric representation that encodes, for each voxel in a scene, the signed distance to the nearest surface, truncated to a fixed maximum value. TSDF extraction refers to the family of methods and algorithmic strategies for constructing, updating, optimizing, and leveraging this representation from sensor data—principally for use in dense 3D reconstruction, real-time SLAM, robot mapping, and scene understanding. Modern TSDF extraction encompasses a range of computational, algorithmic, and hybrid approaches aimed at improving efficiency, accuracy, compressibility, and integration into broader perception frameworks.

1. Core Principles and Mathematical Foundation

A TSDF field encodes, at each voxel location $x$, an estimate of the signed distance to the closest surface $s(x)$, clamped to a maximum truncation value $d_{\text{trunc}}$: $$\text{TSDF}(x) = \operatorname{clamp}_{[-d_{\text{trunc}}, d_{\text{trunc}}]}(d(x)-d_{\text{surf}})$$ where $d(x)$ is the distance from the sensor origin to $x$, and $d_{\text{surf}}$ is the measured range intersection with the observed surface (Song et al., 2023).

The fundamental update loop across classic and modern methods is as follows:

• For each incoming sensor point (e.g., depth pixel, LiDAR return), cast a ray from the sensor origin through the point.
• For each voxel along the ray, update its TSDF value via:

$$D_{i+1}(x) = \frac{W_{i}(x) D_{i}(x) + w(x, p)d(x, p)}{W_{i}(x) + w(x,p)}$$

where $w(x,p)$ is a per-measurement weight, commonly inversely proportional to the measurement's depth squared in vision sensors (Oleynikova et al., 2016).

Truncation constrains the signed distance encoding to a local band around the surface, reducing memory consumption and computational burden, and making the representation robust to spurious data in unobserved regions.

2. Extraction Algorithms and Acceleration Schemes

Ray Marching and Kernel-Based Updates

TSDF extraction is typically performed by traversing rays from the sensor to observed surfaces and updating voxel values as the ray passes through each grid cell. DB-TSDF (Maese et al., 24 Sep 2025) introduces a directional bitmask-based integration: for each LiDAR return, a precomputed, direction-specific update kernel (e.g., 21³ voxels) is assigned to azimuth-elevation bins, and each voxel's bitmask is updated with a bitwise AND with the kernel. This representation enables constant per-point computational cost irrespective of the global grid size and maps naturally to integer arithmetic, making real-time CPU-only operation feasible.

GPU-accelerated frameworks, such as FeatSense (Gaal et al., 2023), leverage parallel CUDA kernels for both the per-scan TSDF ray marching and for weighted averaging into the global field. Thread safety in the presence of concurrent updates to the same voxel is ensured by atomicCAS, and vertical interpolation extending rays into triangles mitigates the spatial gaps between scan lines, ensuring coverage.

Occupancy and Free-Space Encoding

Sign flags or auxiliary fields (often single bits) are used to encode whether a voxel is considered occupied or free, supporting both the assignment of TSDF values and efficient shadowing behind observed surfaces (Maese et al., 24 Sep 2025). Occurrence counters or weights (e.g., 8 bits per voxel) aggregate the number of corroborating observations and control thresholding for confident occupancy inference.

3. Data Structures and Scalability

TSDF extraction algorithms must address scalability in both memory and runtime:

• Dense Voxel Grids: Axis-aligned arrays where each voxel holds the TSDF, sign, and weight/counter; fast updates but high memory.
• Hierarchical Spatial Structures: Hash tables (voxel hashing; (Oleynikova et al., 2016)), OpenVDB, or octrees enable dynamic allocation and near-constant lookup, efficient for sparse or arbitrarily large spaces.
• Bitmask and Integer Encodings: DB-TSDF (Maese et al., 24 Sep 2025) represents each voxel's distance using a 32-bit unsigned bitmask encoding the truncated L₁ distance. Kernel sizes (e.g., 21³) are fixed, enabling constant update stride per LiDAR return.

Constant per-frame update cost is achieved by decoupling local update routines from global grid resolution. For example, $$T_{\text{update}} \approx N_p \cdot K^3 \cdot C_{op}$$, where $N_p$ is the point count, $K$ is the kernel size, and $C_{op}$ is a fixed number of operations per voxel (Maese et al., 24 Sep 2025).

4. Runtime Performance, Compression, and Real-Time Applications

DB-TSDF’s measured runtime is $\sim$150 ms per LiDAR frame at high voxel resolutions (down to 0.05 m), and can be further reduced by mild downsampling (to $\sim$91 ms per frame for $DS=2$), demonstrating near resolution invariance (Maese et al., 24 Sep 2025). FeatSense’s GPU back end achieves speedups up to 100× over previous mapping pipelines on embedded NVIDIA Jetson hardware (Gaal et al., 2023).

Compression of volumetric data is a recurring theme. Eigenshapes (Canelhas et al., 2016) employs PCA and auto-encoder networks for local TSDF block compression, supporting descriptor comparisons for selective decompression. Practical experiments confirm that compressed TSDF blocks (via linear or non-linear codes) preserve sufficient detail for robot mapping and sometimes aid denoising.

5. Fidelity, Accuracy, and Impact on Mapping

Accuracy is measured by geometric error metrics, e.g., chamfer distance, completeness, and F-score, as seen in evaluation against real-world datasets such as Mai City and Newer College (Maese et al., 24 Sep 2025). DB-TSDF achieves F-scores around 96.6%, ranking near the best contemporary approaches and demonstrating preservation of fine details without sacrificing runtime or requiring GPU acceleration. Bitmask integration is noted to preserve edges and corners with minimal computational overhead.

Compression approaches using auto-encoder methods and eigenshape bases show that, for the same absolute trajectory error in robot pose estimation and mesh RMSE, codes as small as 32–128 elements per 16³ block are sufficient (Canelhas et al., 2016). Lossy compression sometimes acts as a denoising filter and can improve downstream tasks such as ego-motion estimation in robotic mapping.

6. Extensions, Limitations, and Future Directions

Research directions highlighted in DB-TSDF (Maese et al., 24 Sep 2025) include:

• Adapting the integration kernel size or shape dynamically based on local geometry (e.g., depth discontinuities).
• Extensions to dynamic scene mapping with more sophisticated update/revision logic for moving objects.
• Incorporating probabilistic reasoning or uncertainty quantification into the evidence counters or occupancy field.
• Further optimizing memory management and multi-threading, with possible hybrid CPU/GPU approaches that retain determinism while leveraging available hardware parallelism.

Some limitations include the challenge of handling highly dynamic environments, and the lack of direct uncertainty quantification in deterministic bitmask approaches.

---

In conclusion, TSDF extraction encompasses a broad spectrum of techniques—from classical ray marching and weighted fusion, through directional kernel bitmask encoding, to modern GPU and deep learning–based approaches. DB-TSDF (Maese et al., 24 Sep 2025) establishes that highly efficient, deterministic, and resolution-invariant mapping is possible on commodity CPUs, with performance and accuracy rivaling GPU-based solutions. These capabilities underpin advances in real-time robotic perception, high-resolution mapping, and efficient data compression for large-scale 3D environments.