Truncated Signed Distance Function (TSDF)

• TSDF is a spatial representation that encodes the truncated signed distance to the nearest surface, enabling robust 3D reconstruction and SLAM.
• The method fuses sensor data using weighted averaging on voxel grids or sparse hash maps to maintain accurate volumetric fusion and surface meshing.
• Extensions like directional and neural TSDFs improve recovery of thin structures and accelerate real-time mapping by reducing pose error.

A Truncated Signed Distance Function (TSDF) is a spatial data representation that encodes the signed distance from each point in ℝ³ to the nearest surface, restricted to a bounded region around the surface. The TSDF forms the backbone of modern algorithms for dense 3D reconstruction, real-time SLAM, and neural surface field modeling, offering robust volumetric fusion, implicit surface definition, and efficient downstream meshing. This article systematically reviews the mathematical formulation of TSDFs, their discrete implementations, fusion and integration algorithms, advanced extensions, and their interaction with neural field methods and compression. The coverage reflects a consensus view from core works in geometric vision, scene modeling, and neural mapping.

1. Mathematical Definition and Core Properties

The TSDF at a point $x\in\mathbb{R}^3$ is defined as a truncation of the signed distance function (SDF) $\phi(x)$: $$\text{TSDF}(x) = \text{sign}(\phi(x)) \, \min\left(|\phi(x)|, \tau\right)$$ with $\tau > 0$ the truncation parameter specifying the half-width of the "integration band." The SDF itself gives: $$\phi(x) = \pm \min_{y\in\partial\Omega} \| x - y \|_2$$ where the sign denotes whether $x$ is outside ($+$) or inside ($-$) the surface $\partial\Omega$.

Normalization to $[-1, 1]$ via division by $\tau$ is common: $F(x) = \frac{\text{TSDF}(x)}{\tau}$ The zero-level set $F(x) = 0$ encodes the inferred surface.

The volumetric TSDF is almost always discretized on a regular or spatially hashed voxel grid, storing a (distance, weight) tuple per voxel for incremental fusion and confidence tracking (Prisacariu et al., 2014, Oleynikova et al., 2016).

2. TSDF Construction from Sensor Data

2.1 Range Sensor Fusion

Given calibrated range images, each voxel center is projected into the camera image to determine the corresponding pixel and measured depth $d_m$. For each voxel $x$:

1. Transform $x$ to camera coordinates.
2. Compute measured signed distance $\eta = d_m - z(x)$, where $z(x)$ is the depth of $x$ in camera coordinates.
3. Truncate: $\phi_s = \mathrm{clamp}(\eta/\tau, -1, +1)$.
4. Fuse $\phi_s$ into the running TSDF and weight.

Point cloud and LiDAR data typically use raycasting: For each hit point $p_i$, voxels along the ray are updated if they are within $\tau$ of $p_i$, assigning positive sign in front of the surface and negative behind (Oleynikova et al., 2016, Gaal et al., 2023).

2.2 Fusion of Multiple Observations

Weighted averaging is the canonical fusion rule: $$D_{\mathrm{new}}(x) = \frac{W_{\mathrm{old}}(x) D_{\mathrm{old}}(x) + w(x) d(x)}{W_{\mathrm{old}}(x) + w(x)}$$

$W_{\mathrm{new}}(x) = W_{\mathrm{old}}(x) + w(x)$

where $w(x)$ is the per-update confidence (e.g., $1$ per hit, $1/z^2$ for depth, or function of incidence angle), and $d(x)$ is the new SDF measurement at $x$, truncated to $[-\tau, \tau]$ (Prisacariu et al., 2014, Oleynikova et al., 2016, Hu et al., 2022).

Adaptive truncation may be used to account for spatially varying sensor density, e.g., via per-block principal component analysis (PCA) to set $\tau$ as a function of flatness and hit-count (Hu et al., 2022).

2.3 Specialized Data Structures

Large-scale TSDF integration uses sparse voxel hashing, dividing space into blocks (e.g., $8^3$ voxels) mapped via a hash table. Only blocks intersecting observed data in the current frame are allocated, supporting dynamic memory scaling (Prisacariu et al., 2014). Dense grid implementations remain relevant for bounded, robot-centric, or embedded deployments (Gaal et al., 2023, Maese et al., 24 Sep 2025).

Bitmask-based TSDF encoding enables highly efficient, thread-parallel integer updates for CPU-only pipelines, at the cost of representing only a fixed set of distance levels per voxel (Maese et al., 24 Sep 2025).

3. Marching Cubes and Surface Extraction

The zero-level set of the TSDF volume represents the reconstructed surface. The Marching Cubes algorithm processes all active voxels (those near the surface, i.e., where the sign of the TSDF changes across voxel corners):

1. For each voxel cell, collect the eight TSDF values at cell corners.
2. Encode their signs as an 8-bit index.
3. Use a precomputed lookup table to determine the required triangle topology.
4. For each triangle, interpolate zero crossings along the relevant edges.

This yields a watertight, orientable surface directly from the volumetric TSDF (Song et al., 2023, Prisacariu et al., 2014). The quality of the surface mesh depends strongly on voxel size and the accuracy and smoothness of the underlying TSDF.

4. Extensions and Advanced Methodologies

4.1 Directional TSDF (DTSDF)

Standard TSDF fusion cannot simultaneously capture both sides of thin structures due to destructive averaging in the integration band. The Directional TSDF allocates six sub-volumes per voxel (one per coordinate axis direction), fusing new data selectively according to surface normal alignment. This preserves opposing surfaces and improves mesh accuracy for thin objects (Splietker et al., 2019, Splietker et al., 2021, Splietker et al., 2023).

DTSDF fusion:

• For each incoming sample $(p,n)$, compute dot-products with direction vectors $\vec{v}_D$.
• Only update sub-volumes where $\langle n, v_D\rangle$ exceeds a threshold.
• At rendering time, combine directions to produce a view-consistent TSDF field for surface extraction or tracking.

Empirical studies show up to 50% reductions in relative pose error and lower mesh error near thin geometry compared to conventional TSDFs (Splietker et al., 2023).

4.2 Neural and Implicit TSDF Representations

Neural field methods, such as EC-SLAM, ESLAM, and InFusionSurf, encode the TSDF not as a dense voxel array but via continuous functions—multi-resolution hash grids, feature planes, or shallow MLPs (Johari et al., 2022, Li et al., 20 Apr 2024, Lee et al., 2023). The loss functions supervise prediction of TSDF values at sampled points, guiding the network to fit projective depth observations.

The main advantages include:

• Substantially reduced memory consumption (scaling as $O(N^2)$ in plane-based methods).
• Continuous, smooth surfaces enabling high-fidelity marching cubes extraction.
• TSDF priors accelerating optimization and convergence in neural SLAM frameworks.

Neural TSDF representations are now prevalent in real-time dense SLAM (Johari et al., 2022, Li et al., 20 Apr 2024), NeRF-based mapping (Lee et al., 2023, Min et al., 2023), and hybrid approaches leveraging explicit TSDF fusion for pretraining.

4.3 Compression and Dimensionality Reduction

Spatially blockwise compression via PCA (“eigenshapes”), autoencoders, and mixed models achieves compression ratios up to $128{:}1$, with minimal loss in map utility for ego-motion estimation (Canelhas et al., 2016). Low-rank tensor decomposition (Tucker, TT, Quantics-TT) enables 4D (time-varying) TSDF storage and query, providing reductions of $1{:}1000$ and beyond, while maintaining reconstruction fidelity (Usvyatsov et al., 2022). Lossless sign compression guarantees mesh topology preservation in learned compressed pipelines (Tang et al., 2020).

5. Computational and Implementation Considerations

5.1 Real-Time and Hardware-Accelerated Pipelines

Hardware design is tuned to the access and update locality of TSDFs:

• GPU: Dense grids with per-voxel updates (Gaal et al., 2023), or hash-based sparse grids and blockwise kernels (Prisacariu et al., 2014).
• CPU: Bitmask-based representations and parallel updates with neighborhood-fixed kernels for constant-time integration irrespective of grid size (Maese et al., 24 Sep 2025).
• Embedded: Direct global grid allocations, raymarch & atomic-CAS fusions on GPUs (Jetson AGX Xavier) to process high-resolution LiDAR streams at $>100\times$ previous FPGA speeds (Gaal et al., 2023).

The choice of voxel resolution, truncation parameter, and weighting controls the tradeoff between detail, noise suppression, throughput, and mesh completeness (Prisacariu et al., 2014, Oleynikova et al., 2016, Hu et al., 2022, Gaal et al., 2023).

5.2 Adaptive and Semantic TSDF Variants

Adaptive truncation, where the width of the SDF integration band is selected per region or per block, permits the representation to flexibly balance density and detail in the presence of non-uniform data (e.g., rotating 3D LiDAR) (Hu et al., 2022). Semantic-informed regularization—e.g., penalizing normal deviations in wall/floor regions—further improves global geometric consistency (see, e.g., "FAWN" (Sokolova et al., 17 Jun 2024), though architectural and formulation details are not available without the manuscript).

6. TSDF in Modern Neural Rendering and SLAM

TSDF volumes have become a core tool for efficient sampling and acceleration in neural surface fields and NeRF-style renderers. TSDF-informed bounds enable pruning of empty space along rays, reducing sample counts by more than $10\times$ while maintaining appearance and geometric quality (Min et al., 2023). In neural SLAM, TSDF losses anchor the optimization, enforce loop closure, and constrain surface geometry in continuous, jointly optimized map representations (Johari et al., 2022, Li et al., 20 Apr 2024). Pretraining neural feature grids with classical TSDF fusion accelerates convergence and enhances early fidelity (Lee et al., 2023).

Table: Representative TSDF Variants, Applications, and Key Features

Variant	Application Domain	Notable Feature
Classical TSDF	Real-time SLAM, meshing	Weighted fusion, marching cubes
Directional TSDF	Thin-structure modeling	Multi-channel per-orientation SDF
Adaptive TSDF	Outdoor LiDAR mapping	Region-varying truncation
Neural TSDF	NeRF, neural SLAM	Continuous, differentiable, memory-efficient
Bitmask TSDF	CPU, high-res mapping	Integer-only, constant-time updates
Compressed TSDF	Map broadcast/storage	Lossy/lossless, blockwise encoding

7. Limitations and Open Problems

Despite wide adoption, TSDFs have key limitations:

• Overlapping truncation bands still cause partial surface loss for unresolved thin structures; DTSDFs address this at extra cost (Splietker et al., 2019, Splietker et al., 2023).
• Truncation width and voxel resolution must be carefully tuned, particularly under heterogenous data or noisy sensors (Hu et al., 2022).
• Marching Cubes may introduce surface aliasing on very thin or curved geometry unless voxel sizes are reduced, at significant memory cost.
• Neural TSDFs are emergent, and high-fidelity, real-time mapping with global consistency remains computationally intensive.

TSDF research continues to address these limitations, including directionality, adaptivity, semantic regularization, and the coupling with high-efficiency neural architectures for both surface and field-based scene representation.