Unblur-SLAM: Dense Neural SLAM for Blurry Inputs

• The paper introduces a two-stage system that fuses feed-forward deblurring with a blur-aware 3D Gaussian splatting backend to robustly handle both motion and defocus blur.
• It employs an adaptive routing policy using quality metrics to decide between standard tracking for sharp frames and sub-frame optimization for heavily blurred inputs.
• Empirical results demonstrate improved pose accuracy and image quality over conventional SLAM methods on benchmarks like TUM-RGBD and Deblur-NeRF.

Unblur-SLAM denotes a class of blur-robust SLAM systems that treat image blur as part of the measurement process rather than as an external nuisance, and, more specifically, the term refers to the RGB pipeline "Unblur-SLAM: Dense Neural SLAM for Blurry Inputs" (Zhang et al., 26 Mar 2026). In that formulation, monocular RGB video containing motion blur and defocus blur is processed by a two-stage architecture: a feed-forward deblurring stage for frames that can be restored reliably, and a blur-aware backend that directly models failed frames through a global 3D Gaussian Splatting (3DGS) representation and an additional blur network that simulates blur formation in 3D space. The system estimates camera poses $T_t \in SE(3)$ together with a sharp global Gaussian map $G$, and adapts computational effort to the amount of blur in each input frame (Zhang et al., 26 Mar 2026).

1. Definition and scope

In the narrow sense, Unblur-SLAM is a dense neural SLAM pipeline for sharp 3D reconstruction from blurred image inputs, designed for monocular RGB sequences with known intrinsics $K$ and scenes that are mostly static (Zhang et al., 26 Mar 2026). It explicitly targets two blur sources: motion blur, modeled as temporal integration during finite exposure, and defocus blur, treated as spatially varying blur learned implicitly by a blur proposal network rather than through a hard-coded thin-lens point spread function (Zhang et al., 26 Mar 2026).

In a broader research sense, "Unblur-SLAM" also describes a design principle already visible in earlier blur-aware SLAM systems: image formation is embedded inside tracking and mapping so that blur is explained by camera motion, exposure, radiance-field rendering, event constraints, or uncertainty weighting rather than merely suppressed by preprocessing. This principle appears in inverse-imaging SLAM with linear HDR radiance and shutter-time pose optimization (Bae et al., 2024), in motion-blur-aware dense RGB-D SLAM with NeRF or 3DGS backends (Wang et al., 2024), in RGB-only Gaussian Splatting SLAM with sub-frame trajectories and blur-consistent rendering (Girlanda et al., 16 Mar 2025), and in event-assisted systems that exploit blur-free temporal differences (Qu et al., 2023, Chen et al., 9 Aug 2025).

A central distinction within this family concerns where blur is handled. Some systems model blur directly in the forward renderer by integrating latent sharp renderings over the shutter interval (Bae et al., 2024, Wang et al., 2024, Girlanda et al., 16 Mar 2025). Others improve robustness indirectly by fusing events, reweighting uncertainty, or filtering unreliable views and pixels (Qu et al., 2023, Jiang et al., 2024, Zhao et al., 24 Feb 2026). The 2026 Unblur-SLAM combines both a feed-forward deblurring front-end and a blur-aware 3DGS backend, thereby spanning preprocessing and in-the-loop blur modeling within one SLAM pipeline (Zhang et al., 26 Mar 2026).

2. Historical and methodological context

The immediate technical background for Unblur-SLAM is the emergence of dense SLAM systems built on radiance fields and Gaussian splatting, which deliver photorealistic mapping but degrade when the photoconsistency assumption is violated by blur. "I$^2$-SLAM: Inverting Imaging Process for Robust Photorealistic Dense SLAM" models the observed pixel as a tone-mapped, noise-corrupted integral of linear HDR radiance along the moving camera trajectory during exposure, with explicit variables for exposure duration, white balance, exposure scalar, camera response function, and continuous-time motion $R_k(t), T_k(t)$ (Bae et al., 2024). "MBA-SLAM: Motion Blur Aware Dense Visual SLAM with Radiance Fields Representation" similarly renders multiple sharp samples along an intra-exposure trajectory and averages them in both tracking and mapping, using either NeRF or 3DGS backends (Wang et al., 2024). "Deblur Gaussian Splatting SLAM" extends this line to RGB-only SLAM by combining blur-aware frame-to-model optimization, online loop closure, global bundle adjustment, and sub-frame Gaussian rendering (Girlanda et al., 16 Mar 2025).

A different lineage handles blur through auxiliary sensing. "Implicit Event-RGBD Neural SLAM" uses a shared implicit radiance field and differentiable CRFs for RGB and event rendering, with an event temporal aggregating objective that remains informative when RGB frames are blurred or HDR-saturated (Qu et al., 2023). "EGS-SLAM: RGB-D Gaussian Splatting SLAM with Events" integrates events with RGB-D and continuous-time 3DGS rendering, introduces a learnable CRF and a no-event loss, and explicitly models the camera trajectory during exposure (Chen et al., 9 Aug 2025). These systems do not deblur frames in the conventional sense; instead, they use event streams as sharp temporal supervision.

Other approaches intervene at different points in the SLAM stack. "SharpSLAM" places a learned deblurring front-end before ORB-SLAM2 and DSP-SLAM, improving feature extraction, segmentation, and DeepSDF-based object reconstruction for agile UAV imagery (Davletshin et al., 2024). "TAMBRIDGE" does not model a point spread function, but improves robustness to motion blur and sensor noise via strategic viewpoint selection, border-mask gating, and joint optimization of sparse reprojection and dense rendering losses in an ORB-VO plus online-3DGS framework (Jiang et al., 2024). "RU4D-SLAM" incorporates blur-integrated rendering and reweighted uncertainty into 4D Gaussian Splatting SLAM for dynamic scenes, downweighting unreliable blurred or moving pixels during tracking while still reconstructing them in the map (Zhao et al., 24 Feb 2026).

Against this background, Unblur-SLAM is distinguished by three explicit claims. First, it is designed to handle both motion blur and defocus blur rather than motion blur alone (Zhang et al., 26 Mar 2026). Second, it adapts computation effort to blur magnitude through a blur-dependent routing policy (Zhang et al., 26 Mar 2026). Third, frames that fail feed-forward deblurring are not discarded; they are directly modeled through the global 3DGS representation and an additional blur network that simulates blur formation in 3D space (Zhang et al., 26 Mar 2026). This suggests an overview of deblurring-front-end and image-formation-in-the-loop philosophies.

3. Two-stage architecture

Unblur-SLAM follows a two-stage pipeline. Stage 1 is a feed-forward single-image deblurring stage for tracking and mapping. Stage 2 is a blur-aware 3DGS refinement stage with a dedicated blur network in the backend (Zhang et al., 26 Mar 2026). The routing between stages is controlled by a no-reference image quality metric, ARNIQA, together with a Laplacian sharpness ratio used to assess deblurring success (Zhang et al., 26 Mar 2026).

For a sharp frame, identified by the condition $s_t < \tau_{\mathrm{sharp}}$, the pipeline skips deblurring and directly invokes DROID-SLAM with a monocular depth prior from OmniData, then updates the 3DGS map using a sharp-frame loss (Zhang et al., 26 Mar 2026). For a blurred frame, the feed-forward deblurring network produces a candidate $\hat{I}_t$. If the deblurring success score exceeds $\tau_{\mathrm{success}}$, the frame is treated as successfully deblurred: DROID-SLAM estimates pose $T_t$ and depth $D_t$, and the backend performs multi-scale blur refinement with exposure compensation and a blur proposal network (Zhang et al., 26 Mar 2026). If the frame fails the first stage, the tracker is skipped for that frame and the system switches to Stage 2, where a set of virtual sub-frame poses is optimized jointly with 3DGS parameters and blur kernels (Zhang et al., 26 Mar 2026).

The first-stage deblurring model is trained to recover the mid-exposure frame. Its training data are generated in two steps: Stage A uses REDS, GoPro, and ReplicaBlurry sequences synthesized by averaging interpolated frames in linear color space; Stage B fine-tunes on DPDD and RealDoF to improve robustness to defocus (Zhang et al., 26 Mar 2026). The stated reconstruction objective is

$G$0

with inverse gamma correction used during training to approximate photometric linearity (Zhang et al., 26 Mar 2026).

The second-stage routing is computationally adaptive. Successfully deblurred frames incur multi-scale residual blur modeling, whereas heavily blurred frames trigger sub-frame rendering with typically $G$1 virtual exposures (Zhang et al., 26 Mar 2026). Sharp frames are the lightweight path; multi-scale BPN refinement and sub-frame modeling increase cost in proportion to blur severity (Zhang et al., 26 Mar 2026). A plausible implication is that the system treats blur magnitude not merely as a nuisance variable but as a scheduler for optimization effort.

4. Blur formation, 3DGS backend, and optimization

The global map is a 3D Gaussian Splatting representation $G$2 whose elements are parameterized by mean $G$3, covariance $G$4, opacity $G$5, and color $G$6 (Zhang et al., 26 Mar 2026). The Gaussian density is

$G$7

and front-to-back alpha blending yields rendered color and depth

$G$8

with

$G$9

where $K$0 (Zhang et al., 26 Mar 2026).

For heavily blurred frames, motion blur is discretized as an average over sub-frames: $K$1 Each rendered sub-frame is then processed by the blur proposal network. For scale $K$2, the exposure-adjusted image is

$K$3

and the BPN output is

$K$4

where $K$5 is a predicted per-pixel kernel and $K$6 is a blending mask (Zhang et al., 26 Mar 2026). Depth conditioning modifies the kernel through

$K$7

The corresponding losses are frame-type dependent. For sharp frames, the mapping term is

$K$8

For successfully deblurred frames, the multi-scale objective is

$K$9

For failed frames, the sub-frame composite is compared to the observation through

$^2$0

with

$^2$1

(Zhang et al., 26 Mar 2026).

Local and global optimization aggregate these frame-specific terms: $^2$2 The regularizer discourages extreme Gaussian elongations (Zhang et al., 26 Mar 2026). When DROID-SLAM refines depth for a keyframe, Gaussian means are updated along the camera ray by

$^2$3

which preserves consistency between depth-corrected keyframes and the global 3DGS map (Zhang et al., 26 Mar 2026).

5. Tracking, local-global optimization, and relation to other blur-aware SLAM strategies

Unblur-SLAM uses DROID-SLAM as the monocular tracker for sharp or successfully deblurred frames and OmniData as the depth warm start (Zhang et al., 26 Mar 2026). The local backend performs DSPO over a sliding window, optimizing camera poses, Gaussian means, exposure compensation parameters, and BPN kernel and mask parameters (Zhang et al., 26 Mar 2026). In heavy-blur mode, the system refines virtual sub-frame camera parameters so that temporally averaged BPN-rendered images match the observation, and these refinements are then propagated into the global trajectory through local and global bundle adjustment (Zhang et al., 26 Mar 2026).

Loop closure is part of the backend rather than an external add-on. Revisits are detected using optical-flow magnitude thresholds and temporal constraints; detected closures trigger pose-graph updates and Gaussian deformation, reducing drift (Zhang et al., 26 Mar 2026). Unlike keyframe filtering strategies, Unblur-SLAM includes all tracker keyframes in backend optimization to leverage blur modeling (Zhang et al., 26 Mar 2026).

This places the system between two established design families. One family estimates sub-frame or intra-exposure trajectories directly from the physical image-formation model. I$^2$4-SLAM optimizes shutter-time camera motion, exposure, white balance, and CRF in a linear HDR domain (Bae et al., 2024); MBA-SLAM estimates start and end poses per frame and averages $^2$5 or $^2$6 time samples in NeRF and 3DGS variants, respectively (Wang et al., 2024); Deblur-SLAM bridges frame-to-frame and frame-to-model optimization, estimating sub-frame trajectories, affine brightness terms, exposure gaps, and a globally consistent RGB-only trajectory with loop closure and global BA (Girlanda et al., 16 Mar 2025). Unblur-SLAM retains the sub-frame philosophy for failed frames, but precedes it with a feed-forward deblurring stage and a blur-dependent scheduler (Zhang et al., 26 Mar 2026).

A second family improves robustness without directly reconstructing latent sharp frames from each blurry image. TAMBRIDGE filters unreliable frames and pixels via viewpoint selection and border-mask gating (Jiang et al., 2024). RU4D-SLAM uses blur-integrated rendering and uncertainty-aware tracking in dynamic scenes, combining uncertainty with semantic masks through RUM and supporting adaptive 4D mapping via learnable opacity weights (Zhao et al., 24 Feb 2026). Event-based systems such as EN-SLAM and EGS-SLAM exploit asynchronous event streams as blur-free supervision (Qu et al., 2023, Chen et al., 9 Aug 2025). Relative to these methods, Unblur-SLAM remains purely image-based, monocular, and explicitly addresses defocus blur in addition to motion blur (Zhang et al., 26 Mar 2026). This suggests a complementary rather than competing position in the design space.

6. Empirical performance, limitations, and significance

Unblur-SLAM is evaluated on TUM-RGBD, IndoorMCD, ReplicaBlurry, ArchViz, and the Deblur-NeRF benchmark (Zhang et al., 26 Mar 2026). Reported pose accuracy improves over DROID-SLAM on the listed averages: on TUM, ATE RMSE is $^2$7 for DROID-SLAM, $^2$8 for Ours*, and $^2$9 for Ours; on MCD, it is $R_k(t), T_k(t)$0 for DROID-SLAM, $R_k(t), T_k(t)$1 for Ours*, and $R_k(t), T_k(t)$2 for Ours (Zhang et al., 26 Mar 2026). On ArchViz, ArchViz-2 reports ATE RMSE and PSNR of $R_k(t), T_k(t)$3 and $R_k(t), T_k(t)$4 for MBA-SLAM versus $R_k(t), T_k(t)$5 and $R_k(t), T_k(t)$6 for Unblur-SLAM, and the average ATE across ArchViz sequences is $R_k(t), T_k(t)$7 for Unblur-SLAM versus $R_k(t), T_k(t)$8 for MBA-SLAM (Zhang et al., 26 Mar 2026).

On the Deblur-NeRF benchmark, the motion-blur subset yields PSNR/SSIM/LPIPS of $R_k(t), T_k(t)$9 for Unblur-SLAM, compared with $s_t < \tau_{\mathrm{sharp}}$0 for the same system without Gaussian refinement and lower PSNR for CoMoGaussian, BAGS, Deblur-GS, and Deblur-NeRF (Zhang et al., 26 Mar 2026). On the defocus subset, the reported PSNR is $s_t < \tau_{\mathrm{sharp}}$1 for Unblur-SLAM versus $s_t < \tau_{\mathrm{sharp}}$2 to $s_t < \tau_{\mathrm{sharp}}$3 for prior baselines (Zhang et al., 26 Mar 2026). On TUM PSNR using I$s_t < \tau_{\mathrm{sharp}}$4-SLAM keyframes and manual sharp annotations, Unblur-SLAM reports $s_t < \tau_{\mathrm{sharp}}$5 versus $s_t < \tau_{\mathrm{sharp}}$6 on fr1_desk, $s_t < \tau_{\mathrm{sharp}}$7 versus $s_t < \tau_{\mathrm{sharp}}$8 on fr2_xyz, and $s_t < \tau_{\mathrm{sharp}}$9 versus $\hat{I}_t$0 on fr3_office (Zhang et al., 26 Mar 2026). A fallback ablation on ReplicaBlurry reports $\hat{I}_t$1 dB with sub-frame modeling versus $\hat{I}_t$2 dB without it (Zhang et al., 26 Mar 2026).

The implementation uses an AMD EPYC-2 7282 CPU and an NVIDIA RTX A6000 (48 GB) GPU. The average throughput on TUM sequences fr1_desk, fr2_xyz, and fr3_office is reported as $\hat{I}_t$3 FPS for the full pipeline and $\hat{I}_t$4 FPS without Gaussian refinement; I$\hat{I}_t$5-SLAM is listed at approximately $\hat{I}_t$6 FPS as a reference point (Zhang et al., 26 Mar 2026). The description attributes the dominant runtime cost to the deblurring network and sub-frame modeling (Zhang et al., 26 Mar 2026).

The limitations are explicit. The system is not real-time in its current form; memory scales with $\hat{I}_t$7 and Gaussian count; rolling shutter and dynamic scenes are not explicitly modeled; mobile-device ISP pipelines may violate the linear-RGB assumptions used in physics-constrained training; and lack of exposure metadata complicates temporal sampling, even though learned exposure compensation alleviates this issue (Zhang et al., 26 Mar 2026). These limitations align with a broader pattern in blur-aware dense SLAM. RGB-only methods that integrate blur into rendering remain computationally heavy (Wang et al., 2024, Girlanda et al., 16 Mar 2025), event-assisted systems require additional hardware and calibration (Qu et al., 2023, Chen et al., 9 Aug 2025), and degradation-aware continuous-time formulations with IMU support become substantially more complex when rolling shutter and sensor-specific effects are included (Carmichael et al., 20 Mar 2026).

Within that broader trajectory, Unblur-SLAM is significant because it operationalizes a hybrid doctrine: deblur when feed-forward restoration is reliable, but fall back to explicit blur formation in the map when it is not (Zhang et al., 26 Mar 2026). This suggests a general template for future dense SLAM under adverse imaging: route easy frames through inexpensive restoration and standard tracking, and reserve full image-formation inversion for cases where blur remains structurally coupled to pose and scene geometry.