Unblur-SLAM: Dense Neural SLAM for Blurry Inputs

May 25, 2026 · View on GitHub

Welcome to the official repository for Unblur-SLAM, a dense neural RGB SLAM pipeline designed for sharp 3D reconstruction from blurry image inputs.

📄 Paper: Unblur-SLAM (arXiv)

🎬 Video: YouTube, Bilibili

Qi Zhang, Denis Rozumny, Francesco Girlanda, Sezer Karaoglu, Marc Pollefeys, Theo Gevers, Martin R. Oswald. Unblur-SLAM: Dense Neural SLAM for Blurry Inputs. CVPR 2026.

📖 Overview

In contrast to previous work, Unblur-SLAM can handle different types of blur and demonstrates strong performance under both motion blur and defocus blur.

The system adapts its computational effort based on the estimated blur level: it treats sharp and blurry frames differently and can skip expensive refinements when appropriate.

🚀 Release Plan

TODO List

Phase 1: Open-source the pre-trained model weights and curated datasets.
- 🏋️ Pre-trained Models: Available on Hugging Face
- 🗄️ Curated Datasets: Available on Hugging Face
Phase 2: Open-source the training code for the deblurring model.
Phase 3: Open-source the inference code of the whole system. (this commit)

Please star or watch this repository to stay updated on our progress.

🛠️ Installation

Clone the repository.

git clone https://github.com/SlamMate/Unblur-SLAM.git
cd Unblur-SLAM

Create a conda environment.

conda create --name unblur-slam python=3.10 -y
conda activate unblur-slam

Install CUDA toolkit and PyTorch.

conda install conda-forge::cudatoolkit-dev=11.7.0 -y
conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia -y
python -c "import torch; print('cuda:', torch.cuda.is_available())"

Patch the Gaussian rasterizer near plane. In our monocular setting the global scale is ambiguous, so we lower the rasterizer's near plane from 0.2 to 0.001. Edit thirdparty/diff-gaussian-rasterization-w-pose/cuda_rasterizer/forward.cu:
```
if (p_view.z <= 0.001f)
```

Install the in-tree extensions.

python -m pip install -e thirdparty/lietorch/
python -m pip install -e thirdparty/diff-gaussian-rasterization-w-pose/
python -m pip install -e thirdparty/simple-knn/
python -m pip install -e thirdparty/evaluate_3d_reconstruction_lib/

Build the DROID backends and install Python requirements.

python -m pip install -e .
python -m pip install -r requirements.txt
python -m pip install pytorch-lightning==1.9 --no-deps

Sanity check.

python -c "import torch, lietorch, simple_knn, diff_gaussian_rasterization; print(torch.cuda.is_available())"

Download pretrained weights into ./pretrained/.

pretrained/
├── droid.pth                       # DROID-SLAM tracker (Splat-SLAM Drive bundle)
├── omnidata_dpt_depth_v2.ckpt      # Omnidata monocular depth (same bundle)
└── evssm/
   ├── net_g_latest.pth             # EVSSM deblurring weights (motion + defocus)
   └── net_g_realblur_j.pth         # optional: RealBlur_J variant

The droid.pth and omnidata_dpt_depth_v2.ckpt come from the original Splat-SLAM Google Drive bundle; see the Splat-SLAM repository for details.

🗄️ Datasets

Place every dataset under ./datasets/ (or symlink). Defaults in the config files assume this layout — change data.dataset_root / data.input_folder if you store data elsewhere.

Deblur-NeRF (motion blur and defocus blur)

We follow the layout of Ma et al. (2022) — see the Deblur-NeRF release. Place the two subsets at:

datasets/real_camera_motion_blur/<scene>/    # motion blur, 10 scenes (blurball, blurbasket, ...)
datasets/real_defocus_blur/<scene>/          # defocus blur, 11 scenes (defocusbush, defocuscake, ...)

I2-SLAM evaluation on TUM-RGBD

The I2-SLAM rendering benchmark uses TUM-RGBD fr1_desk, fr2_xyz, and fr3_office with the I2-SLAM keyframe annotations. Download the TUM sequences with:

bash scripts/download_tum.sh

Then place them at datasets/tum/rgbd_dataset_freiburg{1_desk,2_xyz,3_long_office_household}/.

Replica, ScanNet, ReplicaBlurry, MCD, ArchViz

Configs for these auxiliary benchmarks live under configs/Replica/, configs/Scannet/, configs/ReplicaBlurry/, and configs/MCD/. Helper download scripts are in scripts/.

▶️ Run

Each scene has its own config; the inference entry point is run.py <config>.

Deblur-NeRF — motion blur

python run.py configs/deblur_nerf_motion/blurball.yaml
python run.py configs/deblur_nerf_motion/blurbasket.yaml
python run.py configs/deblur_nerf_motion/blurbuick.yaml
python run.py configs/deblur_nerf_motion/blurcoffee.yaml
python run.py configs/deblur_nerf_motion/blurdecoration.yaml
python run.py configs/deblur_nerf_motion/blurgirl.yaml
python run.py configs/deblur_nerf_motion/blurheron.yaml
python run.py configs/deblur_nerf_motion/blurparterre.yaml
python run.py configs/deblur_nerf_motion/blurpuppet.yaml
python run.py configs/deblur_nerf_motion/blurstair.yaml

Or sweep all 10 with bash run_all_deblur_nerf_motion.sh.

Deblur-NeRF — defocus blur

python run.py configs/deblur_nerf_defocus/defocusbush.yaml
# ...same pattern for defocuscake, defocuscaps, defocuscisco, defocuscoral,
# defocuscupcake, defocuscups, defocusdaisy, defocussausage, defocusseal, defocustools

I2-SLAM rendering benchmark on TUM

python run.py configs/I2slam/freiburg1_desk.yaml
python run.py configs/I2slam/freiburg2_xyz.yaml
python run.py configs/I2slam/freiburg3_office.yaml

Tracking-only mode

Append --only_tracking to skip mapping/rendering and only produce the camera trajectory:

python run.py configs/I2slam/freiburg3_office.yaml --only_tracking

🔬 Pipeline at a glance

Blur quantification with ARNIQA classifies each frame as sharp / blurry-success / blurry-fail.
Sharp & blurry-success frames are tracked with DROID-SLAM and then refined through deformable 3DGS, multi-scale BPN kernels, and exposure compensation.
Blurry-fail frames are modeled with n_virtual_cams sub-frame poses inside the rasterizer to invert motion-blur formation.
Global consistency comes from DSPO/DBA local bundle adjustment, loop closure detection, and a final-stage global BA + multi-scale refinement.

⚠️ Pre-trained Model Loading & Limitations

The pre-trained models can be loaded directly by referring to the EVSSM repository.

For RGB images that have been processed and enhanced by smartphone AI algorithms (computational photography), our algorithm cannot invert these non-linear enhancements to recover the linear RGB values.

📦 Third-party dependencies

If you find any missing third-party libraries in this repository (e.g., a submodule under thirdparty/ that does not download properly), you can directly reuse the corresponding submodule from Splat-SLAM — both repositories use the same third-party components.

Reference repository: https://github.com/google-research/Splat-SLAM
You can either copy the missing components into thirdparty/, or add them as a submodule / subtree.

Alternatively, you can keep a lightweight setup by adding a pointer under thirdparty/ (e.g., a thirdparty/Splat-SLAM.md file) that links to the upstream Splat-SLAM reference libraries.

🙏 Acknowledgements

Our codebase builds on Splat-SLAM, GlORIE-SLAM, GO-SLAM, and related projects.

📝 Citation

If you find our work or datasets helpful in your research, please consider citing our paper:

@inproceedings{unblur_slam_2026,
  title={Unblur-SLAM: Dense Neural SLAM for Blurry Inputs},
  author={Zhang, Qi and Rozumny, Denis and Girlanda, Francesco and Karaoglu, Sezer and Pollefeys, Marc and Gevers, Theo and Oswald, Martin R.},
  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  year={2026}
}

📬 Contact

Open an issue on this repository, or reach Qi Zhang at q.zhang@uva.nl for questions and bug reports.