Kernel-SDF

An open-source library for real-time signed distance function (SDF) estimation using kernel regression.

Kernel-SDF learns a signed distance function with calibrated uncertainty in real-time from streaming sensor data. It combines a front-end that estimates a continuous occupancy field via kernel regression (Bayesian Hilbert Map) with a back-end that estimates accurate SDF via Gaussian Process regression using surface samples from the front-end. The result is accurate SDF, gradient, uncertainty, and mesh reconstruction at real-time rates — suitable for motion planning, manipulation, and navigation.

📄 Paper  ·  📄 Appendix  ·  🌐 Project Page  ·  🏛️ Existential Robotics Lab

Zhirui Dai*, Tianxing Fan*, Mani Amani, Jaemin Seo, Ki Myung Brian Lee, Hyondong Oh, Nikolay Atanasov. "Kernel-SDF: An Open-Source Library for Real-Time Signed Distance Function Estimation using Kernel Regression." IEEE Robotics and Automation Letters (RA-L), 2026. (*Equal contribution)

Demos

Real-time SDF mapping and reconstruction across indoor and large-scale outdoor scenes:

Large-scale outdoor SDF — distance-colored voxel map from streaming 3D LiDAR

Newer College — mesh reconstructed from the estimated SDF

Cow-and-Lady — mesh reconstructed from the estimated SDF

Uncertainty-aware SDF: the predicted distance field comes with a calibrated variance that is low near well-observed surfaces and high in poorly-observed regions.

Predicted SDF (2D slice; red = zero-level surface)

SDF error vs. ground truth

Predicted uncertainty (std. dev.)

Features

• Calibrated uncertainty — per-query SDF variance from Gaussian Process regression, not just a point estimate.
• Real-time — front-end occupancy learning and back-end SDF regression run online on streaming point clouds.
• Accurate SDF, gradient & mesh — hierarchical (octree) BHMs & GPs recover distance, its gradient, and a mesh via marching cubes.
• Sensor-agnostic — works with 2D LiDAR, 3D LiDAR, depth cameras, and raw point clouds.
• C++ core with Python bindings — use it as a CMake package or from Python.
• ROS 1 & ROS 2 — ready-to-run nodes for Noetic, Humble, and Jazzy.

Repository Layout

This is a meta-repository: it aggregates the Kernel-SDF packages as git submodules under src/ and provides top-level build, setup, and Docker tooling.

Package	Description
erl_cmake_tools	Shared CMake macros and build helpers
erl_common	Common utilities (logging, serialization, math)
erl_covariance	Kernel / covariance functions
erl_gaussian_process	Gaussian Process regression
erl_geometry	Geometry, occupancy trees, marching cubes
erl_gp_sdf	Core Kernel-SDF library (front-end + back-end)
erl_common_ros	ROS wrappers for erl_common
erl_geometry_msgs	ROS messages for geometry types
erl_geometry_ros	ROS wrappers for erl_geometry
erl_geometry_rviz_plugin	RViz visualization plugins
erl_gp_sdf_msgs	ROS messages/services for SDF queries
erl_gp_sdf_ros	ROS nodes for real-time SDF mapping & visualization

The first six packages form the core (non-ROS) C++/Python library; the rest add ROS support.

Getting Started

Clone

git clone --recursive https://github.com/ExistentialRobotics/kernel_sdf.git
cd kernel_sdf
# already cloned without --recursive?
git submodule update --init --recursive

Install Dependencies

Setup scripts install all system dependencies for the core (non-ROS) workspace:

bash scripts/setup_ubuntu_22.04.bash   # or setup_ubuntu_20.04 / 24.04 / 26.04
bash scripts/setup_archlinux.bash      # Arch Linux
bash scripts/setup_macos.bash          # macOS (Homebrew; Apple Silicon or Intel)

ROS packages additionally require a ROS distribution (Noetic / Humble / Jazzy) installed separately.

Build

Option 1 — Core library (plain CMake)

Builds the non-ROS C++ library and tests:

mkdir -p build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j"$(nproc)"

Option 2 — ROS workspace

ROS 2 (Humble / Jazzy)

Symlink this repo in as the workspace's src, so the submodules land at src/src — exactly the base-paths that the bundled colcon_defaults.yaml points colcon at. Link that file into the workspace root too and colcon build picks it up automatically:

mkdir -p ros2_ws && cd ros2_ws
ln -s <kernel_sdf_repo_root> src
ln -s src/colcon_defaults.yaml colcon_defaults.yaml

source /opt/ros/<humble|jazzy>/setup.bash
colcon build --symlink-install
source install/setup.bash

ROS 1 (Noetic)

Build the submodules under src/ directly with catkin:

mkdir -p ros1_ws && cd ros1_ws
ln -s <kernel_sdf_repo_root>/src src
source /opt/ros/noetic/setup.bash
catkin build
source devel/setup.bash

Option 3 — Python package

The erl_* packages are compiled from source (CMake + pybind11). Their setup.py locates libtorch through the installed torch, so the third-party runtime dependencies must be present before the packages are built — hence the --no-build-isolation flag below. Install the dependencies first, then build the packages in dependency order, one at a time (each package's build needs the previous ones already installed):

# Optional: isolate everything in a pipenv environment
pipenv install          # creates the virtualenv from Pipfile
pipenv shell            # or prefix the commands below with `pipenv run`

# If you have GCC 16+, you need to install GCC <=15, and run
export CC=/usr/bin/gcc-15
export CXX=/usr/bin/g++-15
export NVCC_PREPEND_FLAGS='-ccbin g++-15'

# 1. Install the third-party Python dependencies (torch, open3d, vedo, ...)
pip install -r requirements.txt

# 2. Build & install the erl_* packages in dependency order
for pkg in erl_cmake_tools erl_common erl_covariance erl_geometry erl_gaussian_process erl_gp_sdf; do
  pip install ./src/$pkg --verbose --no-build-isolation --no-deps
done

Verify the installation:

python -c "import erl_common, erl_covariance, erl_geometry, erl_gaussian_process, erl_gp_sdf; print('OK')"

Option 4 — Docker (recommended for ROS)

Prebuilt Docker tooling handles all dependencies:

# Build images
bash scripts/build_docker_ros1.bash                    # ROS 1 Noetic (Ubuntu 20.04)
ROS_DISTRO=humble bash scripts/build_docker_ros2.bash  # ROS 2 Humble (Ubuntu 22.04)
ROS_DISTRO=jazzy  bash scripts/build_docker_ros2.bash  # ROS 2 Jazzy  (Ubuntu 24.04)

# Create and enter a dev container (with GUI/X11 forwarding)
bash scripts/run_docker.bash <noetic|humble|jazzy>
docker exec -it kernel_sdf_<distro> bash -l

Usage

• Core library (C++ / Python): see erl_gp_sdf for 2D/3D SDF mapping examples and configuration guidance.
• ROS nodes: see erl_gp_sdf_ros for the sdf_mapping_node, topics/services, and pre-configured demos (Cow-and-Lady, Newer College, and more).

Citation

If you use Kernel-SDF in your research, please cite:

@article{dai2026kernelsdf,
    title={Kernel-SDF: An Open-Source Library for Real-Time Signed Distance Function Estimation using Kernel Regression},
    author={Dai, Zhirui and Fan, Tianxing and Amani, Mani and Seo, Jaemin and Lee, Ki Myung Brian and Oh, Hyondong and Atanasov, Nikolay},
    journal={IEEE Robotics and Automation Letters},
    year={2026},
    publisher={IEEE},
}

License

Released under the MIT License. See each submodule for its own license file.

Acknowledgements

This work was supported by ARL DCIST CRA W911NF-17-2-0181, NSF FRR CAREER 2045945, the Ministry of Trade, Industry, and Energy (MOTIE), Korea, under the Strategic Technology Development Program supervised by the Korea Institute for Advancement of Technology (KIAT) [Grant No. P0026052], and the Korea Institute of Planning and Evaluation for Technology in Food, Agriculture, Forestry (IPET) through the Smart Farm Innovation Technology Development Program, funded by the Ministry of Agriculture, Food and Rural Affairs (MAFRA) (RS-2025-02219411).

Developed at the Existential Robotics Lab, UC San Diego, in collaboration with KAIST.