---
title: 'Unblur-SLAM: Dense Neural SLAM for Blurry Inputs'
url: https://www.emergentmind.com/topics/unblur-slam
type: topic
---

# Unblur-SLAM: Dense Neural SLAM for Blurry Inputs

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" [2603.26810]. 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 [2603.26810].

## 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 [2603.26810]. 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 [2603.26810].

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 [2407.11347], in motion-blur-aware dense RGB-D SLAM with NeRF or 3DGS backends [2411.08279], in RGB-only Gaussian Splatting SLAM with sub-frame trajectories and blur-consistent rendering [2503.12572], and in event-assisted systems that exploit blur-free temporal differences [2311.11013, 2508.07003].

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 [2407.11347, 2411.08279, 2503.12572]. Others improve robustness indirectly by fusing events, reweighting uncertainty, or filtering unreliable views and pixels [2311.11013, 2405.19614, 2602.20807]. 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 [2603.26810].

## 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)$ [2407.11347]. "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 [2411.08279]. "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 [2503.12572].

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 [2311.11013]. "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 [2508.07003]. 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 [2410.05405]. "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 [2405.19614]. "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 [2602.20807].

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 [2603.26810]. Second, it adapts computation effort to blur magnitude through a blur-dependent routing policy [2603.26810]. 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 [2603.26810]. This suggests a synthesis 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 [2603.26810]. 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 [2603.26810].

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 [2603.26810]. 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 [2603.26810]. 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 [2603.26810].

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 [2603.26810]. The stated reconstruction objective is
\[
\mathcal{L}_{\mathrm{deblur}}^{\mathrm{stage1}} = \| \hat{I}_{\mathrm{mid}} - I_{\mathrm{mid}}^{\mathrm{GT}} \|_1,
\]
with inverse gamma correction used during training to approximate photometric linearity [2603.26810].

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 $N_{\mathrm{sub}} = 3$ virtual exposures [2603.26810]. Sharp frames are the lightweight path; multi-scale BPN refinement and sub-frame modeling increase cost in proportion to blur severity [2603.26810]. 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 = \{g_i\}$ whose elements are parameterized by mean $\mu_i \in \mathbb{R}^3$, covariance $\Sigma_i = R_i S_i S_i^\top R_i^\top$, opacity $o_i \in [0,1]$, and color $c_i \in \mathbb{R}^3$ [2603.26810]. The Gaussian density is
\[
g_i(x) = \exp\!\Big( -\tfrac{1}{2} (x - \mu_i)^\top \Sigma_i^{-1} (x - \mu_i) \Big),
\]
and front-to-back alpha blending yields rendered color and depth
\[
C(u) = \sum_{i \in \mathcal{S}(u)} c_i\, \alpha_i(u)\, T_i(u), \qquad
D_r(u) = \sum_{i \in \mathcal{S}(u)} d_i\, \alpha_i(u)\, T_i(u),
\]
with
\[
T_i(u) = \prod_{j < i} \big( 1 - \alpha_j(u) \big),
\]
where $\alpha_i(u) = o_i\, g_i^{2D}(u)$ [2603.26810].

For heavily blurred frames, motion blur is discretized as an average over sub-frames:
\[
I_{\mathrm{blur}}(u) \approx \frac{1}{N_{\mathrm{sub}}} \sum_{k=1}^{N_{\mathrm{sub}}} I\!\big(u; T(t_k), G \big).
\]
Each rendered sub-frame is then processed by the blur proposal network. For scale $s$, the exposure-adjusted image is
\[
I_{\mathrm{adjusted}}^s(x) = \exp(a_{\mathrm{exposure}}^s)\, I_{\mathrm{rendered}}^s(x) + b_{\mathrm{exposure}}^s,
\]
and the BPN output is
\[
I_{\mathrm{out}}^s(x) = (1 - m^s(x))\, I_{\mathrm{adjusted}}^s(x) + m^s(x)\, \big( I_{\mathrm{adjusted}}^s(x) \otimes h^s(x) \big),
\]
where $h^s(x)$ is a predicted per-pixel kernel and $m^s(x)$ is a blending mask [2603.26810]. Depth conditioning modifies the kernel through
\[
h^s(x, D(x)) = h_{\mathrm{deblur}}^s(D(x)) + \alpha(D(x))\, h_{\mathrm{sharpen}}^s(D(x)).
\]

The corresponding losses are frame-type dependent. For sharp frames, the mapping term is
\[
\mathcal{L}_{\mathrm{sharp}} = w_{\mathrm{sharp}} \Big[ \lambda_{\mathrm{rgb}} \| I_{\mathrm{rendered}} - I_{\mathrm{obs}} \|_1 + \lambda_{\mathrm{depth}} \| D_{\mathrm{rendered}} - D_{\mathrm{obs}} \|_1 \Big].
\]
For successfully deblurred frames, the multi-scale objective is
\[
\mathcal{L}_{\mathrm{deblur}}^s = \lambda_{\mathrm{rgb}} \| I_{\mathrm{out}}^s - I_{\mathrm{obs}}^s \|_1 + \lambda_{\mathrm{depth}} \| D_{\mathrm{out}}^s - D_{\mathrm{obs}}^s \|_1 + \lambda_{\mathrm{sparse}} \| m^s \|_1.
\]
For failed frames, the sub-frame composite is compared to the observation through
\[
\mathcal{L}_{\mathrm{fail}} = \sum_{Q \in \{I^s, D^s\}} \lambda_Q \| \hat{Q}^s - Q_{\mathrm{obs}}^s \|_1 + \lambda_{\mathrm{sparse}} \| m^s \|_1,
\]
with
\[
\hat{Q}^{s} = \frac{1}{N_{\mathrm{sub}}} \sum_{j=1}^{N_{\mathrm{sub}}} \mathrm{BPN}\big( Q_j^s, h_j^s, m_j^s \big)
\]
[2603.26810].

Local and global optimization aggregate these frame-specific terms:
\[
\mathcal{L}_{\mathrm{total}} = \sum_{f \in \mathcal{F}} w_f\, \mathcal{L}_f,
\qquad
\mathcal{L}_{\mathrm{global}} = \sum_{f \in \mathcal{F}} w_f\, \mathcal{L}_f + \lambda_{\mathrm{reg}} \sum_{i=1}^{N} \| s_i - \bar{s} \|_1.
\]
The regularizer discourages extreme Gaussian elongations [2603.26810]. When DROID-SLAM refines depth for a keyframe, Gaussian means are updated along the camera ray by
\[
\mu_i' = \mu_i + \frac{d' - d}{d}\, \big( \mu_i - t_K \big),
\]
which preserves consistency between depth-corrected keyframes and the global 3DGS map [2603.26810].

## 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 [2603.26810]. The local backend performs DSPO over a sliding window, optimizing camera poses, Gaussian means, exposure compensation parameters, and BPN kernel and mask parameters [2603.26810]. 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 [2603.26810].

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 [2603.26810]. Unlike keyframe filtering strategies, Unblur-SLAM includes all tracker keyframes in backend optimization to leverage blur modeling [2603.26810].

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$-SLAM optimizes shutter-time camera motion, exposure, white balance, and CRF in a linear HDR domain [2407.11347]; MBA-SLAM estimates start and end poses per frame and averages $n=7$ or $n=13$ time samples in NeRF and 3DGS variants, respectively [2411.08279]; 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 [2503.12572]. Unblur-SLAM retains the sub-frame philosophy for failed frames, but precedes it with a feed-forward deblurring stage and a blur-dependent scheduler [2603.26810].

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 [2405.19614]. 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 [2602.20807]. Event-based systems such as EN-SLAM and EGS-SLAM exploit asynchronous event streams as blur-free supervision [2311.11013, 2508.07003]. Relative to these methods, Unblur-SLAM remains purely image-based, monocular, and explicitly addresses defocus blur in addition to motion blur [2603.26810]. 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 [2603.26810]. Reported pose accuracy improves over DROID-SLAM on the listed averages: on TUM, ATE RMSE is $0.380$ for DROID-SLAM, $0.352$ for Ours*, and $0.336$ for Ours; on MCD, it is $0.138$ for DROID-SLAM, $0.155$ for Ours*, and $0.128$ for Ours [2603.26810]. On ArchViz, ArchViz-2 reports ATE RMSE and PSNR of $0.0036$ and $30.16$ for MBA-SLAM versus $0.0027$ and $32.71$ for Unblur-SLAM, and the average ATE across ArchViz sequences is $0.0056$ for Unblur-SLAM versus $0.0084$ for MBA-SLAM [2603.26810].

On the Deblur-NeRF benchmark, the motion-blur subset yields PSNR/SSIM/LPIPS of $29.49/0.9213/0.0728$ for Unblur-SLAM, compared with $28.22/0.9007/0.1053$ for the same system without Gaussian refinement and lower PSNR for CoMoGaussian, BAGS, Deblur-GS, and Deblur-NeRF [2603.26810]. On the defocus subset, the reported PSNR is $27.45$ for Unblur-SLAM versus $24.12$ to $24.21$ for prior baselines [2603.26810]. On TUM PSNR using I$^2$-SLAM keyframes and manual sharp annotations, Unblur-SLAM reports $28.03$ versus $27.23$ on fr1_desk, $31.14$ versus $32.06$ on fr2_xyz, and $29.22$ versus $28.91$ on fr3_office [2603.26810]. A fallback ablation on ReplicaBlurry reports $29.94$ dB with sub-frame modeling versus $29.38$ dB without it [2603.26810].

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 $0.74$ FPS for the full pipeline and $0.85$ FPS without Gaussian refinement; I$^2$-SLAM is listed at approximately $0.095$ FPS as a reference point [2603.26810]. The description attributes the dominant runtime cost to the deblurring network and sub-frame modeling [2603.26810].

The limitations are explicit. The system is not real-time in its current form; memory scales with $N_{\mathrm{sub}}$ 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 [2603.26810]. These limitations align with a broader pattern in blur-aware dense SLAM. RGB-only methods that integrate blur into rendering remain computationally heavy [2411.08279, 2503.12572], event-assisted systems require additional hardware and calibration [2311.11013, 2508.07003], and degradation-aware continuous-time formulations with IMU support become substantially more complex when rolling shutter and sensor-specific effects are included [2603.20443].

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 [2603.26810]. 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.

Source: https://www.emergentmind.com/topics/unblur-slam