Kernel-SDF: An Open-Source Library for Real-Time Signed Distance Function Estimation using Kernel Regression

1. Problem Statement

Robotic applications (navigation, manipulation, motion planning) require accurate, efficient, and scalable geometric representations of the environment. Signed Distance Functions (SDFs) are ideal for this as they provide distance to obstacles, gradients for optimization, and support for collision checking. However, existing methods face significant limitations when dealing with streaming sensor data in large-scale, uncertain environments:

• Voxel-based methods (e.g., Voxblox, TSDF): Limited by fixed resolution, lack uncertainty quantification, and are often not differentiable.
• Neural Network methods (e.g., DeepSDF, NeRF): Require significant training time, making them unsuitable for online/real-time learning in novel environments.
• Gaussian Process (GP) methods: While capable of uncertainty quantification, they struggle with scalability (computational cost of matrix inversion), robust sign estimation (distinguishing inside/outside), and uncertainty calibration (variance often explodes far from the surface).

Goal: Develop a real-time system that learns continuous SDFs from streaming point clouds with calibrated uncertainty quantification, scalability, and differentiability.

---

2. Methodology: Kernel-SDF

Kernel-SDF is an open-source C++ library (with Python/ROS interfaces) that employs a two-stage kernel regression framework organized via an octree data structure to ensure scalability.

A. Architecture Overview

The system is divided into a Front-End (Surface Estimation) and a Back-End (SDF Prediction), both utilizing kernel regression but with different objectives.

B. Front-End: Bayesian Hilbert Map (BHM) for Surface Estimation

• Objective: Learn a continuous occupancy field to robustly determine the sign (occupied vs. free) and extract surface points.
• Mechanism:
  • Uses a Bayesian Hilbert Map (BHM) to learn a log-odds field $l(x)$ via kernel regression.
  • Octree Partitioning: To handle large scenes, the environment is split into octants. A local BHM is maintained only for occupied octants.
  • Weight Synchronization: To ensure global consistency, "managed" weights (shared between neighboring octants) are periodically synced.
  • Sign Prediction: The sign of a point is determined by comparing the log-odds $l(x)$ against a learned threshold $\tau$. The threshold is updated online using a moving average of log-odds from hit samples to adapt to sensor viewing angles (e.g., ground vs. walls).
  • Surface Extraction: The Marching Cubes algorithm is applied to the log-odds field to extract surface points $\{x_i\}$.
  • Uncertainty Estimation: The uncertainty of each extracted surface point is calculated based on the deviation of the log-odds from the threshold and the gradient magnitude. This uncertainty is passed to the back-end.

C. Back-End: Gaussian Process (GP) for SDF Prediction

• Objective: Learn the Unsigned Distance Function (UDF) $u(x)$ from the surface points provided by the front-end, then combine with the sign to form the SDF $d(x) = s(x) \cdot u(x)$.
• Mechanism:
  • Log-GP Formulation: Utilizes the relationship between UDF and heat diffusion (Varadhan's formula). It models $f(x) = \exp(-\lambda u(x))$ using GP regression.
  • Kernel Optimization: While standard Log-GP uses the Matérn 3/2 kernel, Kernel-SDF extends this to RBF kernels for better computational efficiency. It introduces a scaling factor $\gamma$ to prevent numerical underflow when kernel scales are small.
  • Softmin-Based Uncertainty Quantification: Standard variance propagation fails in Log-GP (variance explodes far from the surface). Kernel-SDF approximates the UDF as a softmin function over surface points. This allows the propagation of surface point uncertainties ($\sigma_i^2$) directly to the SDF and gradient predictions, ensuring the uncertainty estimates remain consistent with actual errors.
  • Local GP Fusion: Each octant maintains its own GP. Predictions are fused by taking the minimum of the $K$ nearest GP predictions to ensure consistency across boundaries.

D. Efficiency Optimizations

• Priority Queue Updates: Instead of updating the entire map for every sensor frame, the system uses a priority queue to delay surface extraction and GP retraining. Frequently queried regions are updated first, while stable regions are updated less often.
• Sparse Representations: Exploits the sparsity of RBF kernels (vanishing far from hinge points) to reduce computational complexity.

---

3. Key Contributions

1. Open-Source Library: A C++ implementation with Python and ROS1/ROS2 interfaces, featuring extensive real-time testing.
2. Hybrid Kernel Regression Framework: A novel two-component architecture:
   • BHM Front-End: For continuous occupancy learning and robust sign/surface extraction with uncertainty-aware sampling.
   • GP Back-End: For SDF and gradient prediction with calibrated uncertainty using a softmin-based fusion strategy.
3. Scalability & Efficiency: Achieves real-time performance via octree partitioning, weight synchronization, and priority-queue-based updates.
4. Calibrated Uncertainty: Introduces a method to propagate surface point uncertainty directly to SDF predictions, solving the "variance explosion" issue common in existing GP-based SDF methods.

---

4. Experimental Results

The authors evaluated Kernel-SDF against Voxblox, FIESTA, iSDF, and VDB-GPDF on datasets including Replica, Cow and Lady, and Newer College.

• Reconstruction Accuracy:
  • Mesh Quality: Kernel-SDF produces meshes with higher F1 scores, recall, and precision compared to baselines. It preserves fine geometric details (e.g., bed textures, cow horns) that voxel methods miss or neural methods over-smooth.
  • SDF & Gradient Accuracy: Achieved the lowest Mean Absolute Error (MAE) for both SDF values and gradients across "Near" (close to surface) and "Far" regions.
• Computational Efficiency:
  • Achieved real-time performance (~150ms per frame update) across varying scene scales.
  • Significantly faster than Voxblox (which suffers from BFS integration overhead) and iSDF (which requires multi-iteration convergence).
• Uncertainty Consistency:
  • Demonstrated a strong correlation between estimated SDF variance and actual SDF error. Regions with high error (e.g., noisy areas) correctly showed high estimated variance, unlike other methods where variance often becomes uninformative.
• Robustness:
  • Maintained performance under increasing sensor noise levels, outperforming baselines that degraded significantly.
• Real-World Application:
  • Successfully demonstrated on a Clearpath Jackal robot for safe navigation. The system generated "safe bubbles" (based on SDF minus uncertainty margins) for risk-aware path planning.

---

5. Significance

Kernel-SDF addresses the critical gap between accuracy, scalability, and uncertainty quantification in robotic mapping.

• Risk-Aware Robotics: By providing calibrated uncertainty, it enables robots to make safer decisions in dynamic or noisy environments (e.g., slowing down in high-uncertainty zones).
• Differentiability: Unlike voxel maps, the continuous nature of Kernel-SDF supports gradient-based optimization for trajectory planning and manipulation.
• Practicality: The open-source nature and real-time performance make it immediately applicable to current robotic systems requiring reliable geometric perception.

In summary, Kernel-SDF represents a state-of-the-art solution for real-time SDF estimation, effectively combining the robustness of Bayesian occupancy mapping with the predictive power of Gaussian Processes.