Paper deep dive
MotionGS-SLAM: Event-Modulated Gaussian Splatting for Motion-Blur Robust SLAM
Zhiqiang Hu, Shouren Huang, Masatoshi Ishikawa
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 90%
Last extracted: 8/18/2026, 5:14:59 AM
Summary
The paper introduces MotionGS-SLAM, a Simultaneous Localization and Mapping system that addresses motion blur in visual SLAM by leveraging event cameras. Instead of deblurring images, it models blur formation generatively within a 3D Gaussian Splatting pipeline. The system uses an event-modulated Gaussian kernel with dual modulation (spatial and temporal) to adapt Gaussian rasterization based on motion cues from event streams. This allows for robust tracking and high-fidelity map reconstruction under severe motion blur conditions.
Entities (11)
Relation Signals (8)
MotionGS-SLAM → addresses → Motion Blur
confidence 95% · MotionGS-SLAM: Event-Modulated Gaussian Splatting for Motion-Blur Robust SLAM
MotionGS-SLAM → basedon → 3D Gaussian Splatting
confidence 95% · The recent introduction of 3D Gaussian Splatting (3DGS) [10] into the SLAM pipeline... We present MotionGS-SLAM
MotionGS-SLAM → uses → Event Camera
confidence 95% · By leveraging event cameras’ microsecond temporal resolution and immunity to motion blur, we introduce a novel event-modulated Gaussian kernel
Event-Modulated Gaussian Kernel → hasmechanism → Temporal Modulation
confidence 90% · while adaptively varying exposure integral sampling density based on local velocity (temporal modulation).
Event-Modulated Gaussian Kernel → hasmechanism → Spatial Modulation
confidence 90% · Our dual-modulation mechanism transforms 2D Gaussian projections... (spatial modulation)
MotionGS-SLAM → outperforms → Photo-SLAM
confidence 85% · Photo-SLAM and Mono-GS struggle significantly... In stark contrast, the bottom row showcases results from MotionGS-SLAM (Ours).
MotionGS-SLAM → outperforms → Mono-GS
confidence 85% · Photo-SLAM and Mono-GS struggle significantly... In stark contrast, the bottom row showcases results from MotionGS-SLAM (Ours).
→ →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Current Vision-based SLAM systems fail catastrophically when motion blur corrupts the visual input, as they attempt the ill-posed inverse problem of recovering sharp content from degraded observations. We present MotionGS-SLAM, which fundamentally reimagines motion blur handling through a paradigm shift: rather than removing blur artifacts, we reformulate the challenge as a well-constrained forward problem that generatively models blur formation within the rendering pipeline. By leveraging event cameras' microsecond temporal resolution and immunity to motion blur, we introduce a novel event-modulated Gaussian kernel that dynamically adapts each Gaussian's rasterization based on precise motion cues. Our dual-modulation mechanism transforms 2D Gaussian projections from isotropic dots into anisotropic, motion-aligned elliptical brush strokes (spatial modulation) while adaptively varying exposure integral sampling density based on local velocity (temporal modulation). This physics-based approach enables joint optimization of intra-exposure camera trajectories and 3D scene geometry through blur-aware photometric and event-based constraints. Extensive experiments demonstrate significant improvements over state-of-the-art methods in trajectory accuracy and map quality under severe high-motion conditions.
Tags
Links
- Source: https://arxiv.org/abs/2608.15024v1
- Canonical: https://arxiv.org/abs/2608.15024v1
Trouble viewing inline? Open PDF directly →
Full Text
43,897 characters extracted from source content.
Expand or collapse full text
MotionGS-SLAM: Event-Modulated Gaussian Splatting for Motion-Blur Robust SLAM Zhiqiang HU Shouren HUANG Masatoshi ISHIKAWA Thanks: Thanks: The authors are with the Research Institute for Science & Technology, Tokyo University of Science zhiqiang.hu, huang, ishikawa@ishikawa-vision.org Abstract Current Vision-based SLAM systems fail catastrophically when motion blur corrupts the visual input, as they attempt the ill-posed inverse problem of recovering sharp content from degraded observations. We present MotionGS-SLAM, which fundamentally reimagines motion blur handling through a paradigm shift: rather than removing blur artifacts, we reformulate the challenge as a well-constrained forward problem that generatively models blur formation within the rendering pipeline. By leveraging event cameras’ microsecond temporal resolution and immunity to motion blur, we introduce a novel event-modulated Gaussian kernel that dynamically adapts each Gaussian’s rasterization based on precise motion cues. Our dual-modulation mechanism transforms 2D Gaussian projections from isotropic dots into anisotropic, motion-aligned elliptical brush strokes (spatial modulation) while adaptively varying exposure integral sampling density based on local velocity (temporal modulation). This physics-based approach enables joint optimization of intra-exposure camera trajectories and 3D scene geometry through blur-aware photometric and event-based constraints. Extensive experiments demonstrate significant improvements over state-of-the-art methods in trajectory accuracy and map quality under severe high-motion conditions. I Introduction Simultaneous Localization and Mapping (SLAM) is a cornerstone of robot autonomous systems, empowering robots to navigate and interact with unknown environments [2, 20]. While classical visual SLAM systems excel at localization, they often produce sparse geometric maps. The recent introduction of 3D Gaussian Splatting (3DGS) [10] into the SLAM pipeline has marked a significant leap forward, enabling the creation of dense, photorealistic scene representations in real-time [22, 9, 13]. These GS-SLAM systems hold immense promise for applications like augmented reality and digital twinning. However, the impressive performance of current GS-SLAM methods is predicated on a critical assumption: the availability of high-quality, sharp input images. This assumption frequently breaks down in real-world robotic applications, particularly during aggressive motion or in low-light environments that necessitate long exposures as shown in Fig. 1. To compensate for dim lighting, cameras rely on long exposure times, which inevitably leads to severe motion blur. This blur corrupts the high-frequency details essential for feature matching, resulting in degraded camera tracking and, consequently, a corrupted 3D Gaussian map filled with artifacts. While some approaches have attempted to tackle this by integrating deblurring modules like [12], they often struggle with severe, persistent blur as they attempt to invert a highly degraded signal rather than modeling the underlying physical process. Fig. 1: MotionGS-SLAM in action. Existing Vision-based SLAM systems fail in challenging high-motion scenarios due to severe motion blur in the input frames (top row). Our method leverages the co-located event stream to explicitly model the physical process of blur formation. This allows MotionGS-SLAM to robustly track the camera and reconstruct sharp, high-fidelity scenes (bottom row) directly from the degraded imagery, where other methods would fail. Fig. 2: Overview of the MotionGS-SLAM pipeline. Our system takes a blurry RGB image and a stream of events as input. The core of our method is the Event-Modulated Gaussian Kernel, which leverages events to physically model motion blur. (1) Event-Gaussian Association: For each projected Gaussian, we use a 4D spatio-temporal hash grid to efficiently query associated events. From these, we compute local motion statistics (velocity νj _j, direction ϕj _j). (2) Kernel Modulation: These statistics drive our novel dual-modulation mechanism, anisotropically scaling the projected 2D Gaussian’s shape (spatial modulation) to replicate the motion streak. (3) Physics-Based Rendering: Our renderer uses the modulated kernels and an interpolated camera trajectory (TstT_st, TedT_ed) to synthesize a blurred image that matches the real observation. This entire differentiable process is used in two threads: a real-time Tracking front-end that optimizes only the camera trajectory, and a Mapping back-end that performs joint optimization over a keyframe window to refine both the 3D Gaussian map and poses. The fundamental insight of this work is a paradigm shift in how we approach motion blur in visual SLAM. Rather than treating motion blur as an undesirable artifact to be removed through deconvolution, we embrace it as the natural physical consequence of camera motion during exposure and model it generatively. Our key observation is that traditional deblurring methods attempt to solve a severely ill-posed inverse problem recovering sharp content from degraded observations where critical high-frequency information has been irreversibly lost. In contrast, we reformulate this challenge as a well-constrained forward problem: leveraging the high-temporal-resolution motion cues from event cameras, we physically simulate the blur formation process within our differentiable renderer, actively “painting” blur that matches the observed degraded images. To realize this vision, we introduce MotionGS-SLAM. Our system models the intra-exposure camera trajectory as a continuous path in (3)SE(3) space. Given the typically brief exposure intervals, we parameterize each trajectory segment using only its boundary poses the camera configurations at the exposure’s onset and conclusion. During tracking, we optimize these pose pairs by enforcing photometric consistency between the observed blurry frames and our physically-rendered blur simulations. This joint constraint of event-guided motion estimation and blur-aware photometric alignment substantially enhances tracking precision. In the mapping phase, we perform joint optimization over both the trajectories of strategically selected keyframes and the 3D Gaussian scene representation. This optimization minimizes a combined objective of photometric reconstruction error and event-based geometric constraints, resulting in sharp, geometrically accurate maps despite severely degraded input imagery. The technical cornerstone of our approach is an event-modulated Gaussian kernel that dynamically adapts how each 3D Gaussian is rasterized onto the image plane. This adaptation operates through a dual-modulation mechanism: Spatial Modulation: Guided by local motion statistics extracted from the event stream, we transform each Gaussian’s 2D projection from an isotropic circular “dot” into an anisotropic elliptical “brush stroke.” The ellipse’s orientation aligns with the detected motion direction while its eccentricity scales with motion magnitude, geometrically replicating the characteristic streak patterns of motion blur. Temporal Modulation: We adaptively adjust the temporal sampling density of the exposure integral based on the scene’s aggregate motion. Frames with higher average motion velocity, computed across all visible Gaussians, are rendered with a greater number of discrete camera poses.This strategy accurately models the cumulative photometric effect while maintaining computational efficiency. Our main contributions are summarized as follows: • We propose MotionGS-SLAM, that tackles motion blur from a physics-based perspective. Instead of treating blur as an artifact to be removed, we model its physical formation process within the renderer, guided by an event camera. • We introduce an event-modulated Gaussian kernel featuring a dual-modulation strategy. It dynamically adapts the spatial shape and temporal sampling density of projected Gaussians based on local motion statistics derived efficiently from events via a 4D hash grid. • We demonstrate that our system, which requires no depth sensor, significantly outperforms state-of-the-art visual and GS-SLAM methods in both tracking accuracy and reconstruction quality on challenging synthetic and real-world sequences with severe motion blur. I Related Works I-A Gaussian Splatting based SLAM The introduction of 3D Gaussian Splatting [10] has recently enabled a new class of SLAM systems that create dense, photorealistic maps in real time. Pioneering works like GS-SLAM [22], SplaTAM [9], MonoGS [13], Sgs-slam [11], Large spatial model [6] and Compact 3d gaussian splatting [5] successfully integrated 3DGS into a unified tracking and mapping framework, demonstrating remarkable results on high-quality video sequences. These systems established the viability of using an explicit, differentiable representation for both localization and scene reconstruction. However, the core assumption of sharp, well-exposed images makes these methods brittle. Recognizing this, subsequent works have attempted to address the challenge of motion blur. While approaches like I2-SLAM [1] model the camera’s imaging process, these image-only methods are fundamentally constrained. They attempt to recover lost information from an already corrupted signal, an approach that fails when severe motion makes the blur too ambiguous to reliably invert. Our work differs by leveraging a secondary, high-frequency modality to directly inform the rendering of motion, rather than relying solely on the degraded image. I-B Event-based 3D Gaussian Splatting/NeRF The asynchronous nature and inherent immunity to motion blur make event cameras particularly advantageous for three-dimensional scene reconstruction. A recent surge of research has focused on combining event streams with NeRF/3DGS. E2NeRF [15] integrates both blurred image supervision and event-based constraints to recover high-fidelity NeRF representations from severely degraded inputs. Building upon this, Ev-DeblurNeRF [3] introduces a learned event-to-intensity mapping that effectively suppresses event noise, leading to enhanced reconstruction fidelity. Meanwhile, the method in [16] demonstrates the feasibility of event-guided implicit neural SLAM by fusing event streams with RGB-D inputs, achieving robust tracking under motion blur and lighting variation through a differentiable CRF rendering technique. Methods like EvaGaussians [23] and Event3DGS [21, 7] have shown that by leveraging event data, it is possible to reconstruct crisp, detailed 3D Gaussian scenes from a set of blurry images. These works successfully demonstrate the power of events for high-fidelity reconstruction. However, these are primarily offline reconstruction pipelines that require pre-computed camera poses (e.g., via SfM), rendering them incapable of online SLAM. Our work bridges this critical gap by integrating our event-guided generative rendering directly into the front-end tracking loop. This enables a complete and robust online GS-SLAM system that succeeds where prior methods fail. I Method The core architecture of our method is shown in Fig. 2. I-A Motion Blur Image Formation Model We represent the scene as a set of 3D Gaussians =giG=\g_i\, where each Gaussian is defined by a mean i∈ℝ3 μ_i ^3, covariance i∈ℝ3×3 _i ^3× 3, color i c_i, and opacity oio_i. In a standard static rendering, each 3D Gaussian is projected onto the 2D image plane given a single camera pose T, and the final color ()C( u) at a pixel u is computed via α-blending. However, motion blur is a physical process of light integration over a non-zero exposure interval Δtm t_m, during which the camera is moving. We model the camera’s continuous trajectory (t)T(t) for t∈[tst,ted]t∈[t_st,t_ed] by interpolating a start pose stT_st and an end pose edT_ed. The resulting blurred image ¯m C_m is the temporal integral of infinitesimally short exposures along this path. This is approximated by discretely summing N latent sharp images: ¯m()≈1N∑k=1N((tk),). C_m( u)≈ 1N _k=1^NC(T(t_k), u). (1) where ((tk),)C(T(t_k), u) is the sharp image rendered at an intermediate pose (tk)T(t_k). Camera Motion Trajectory Modeling We parameterize the camera motion using two poses: the exposure start st∈(3)T_st (3) and end ed∈(3)T_ed (3). The pose at any time t∈[0,1]t∈[0,1] during exposure is: (t)=st⋅exp(t⋅log(st−1⋅ed)),T(t)=T_st· (t· (T_st^-1·T_ed)), (2) where exp and log are the exponential and logarithm maps on (3)SE(3). I-B Motion Blur Aware Tracker Real-Time Event-Gaussian Association To provide each Gaussian with its local motion context, we must efficiently associate it with the relevant subset of events. A brute-force search is computationally infeasible for real-time operation. 4D Hash Grid. We employ a multi-resolution hash grid to index events in a 4D spatio-temporal domain. Each event e=(x,y,t,p)e=(x,y,t,p) is characterized by its spatial coordinates (x,y)∈ℝ2(x,y) ^2, timestamp t∈ℝt , and polarity p∈−1,+1p∈\-1,+1\ indicating brightness decrease or increase, respectively. Query Process. For each visible 3D Gaussian gjg_j, we project it to the 2D image plane, obtaining its mean ^j μ_j and covariance ^j _j. We then query the hash grid for all events within the 3σ3σ axis-aligned bounding box of the 2D Gaussian and within the camera’s exposure window [tst,ted][t_st,t_ed]. We refine this candidate set by retaining only the events ℰjE_j that satisfy the Mahalanobis distance criterion: (−^j)⊤^j−1(−^j)≤τ,( p- μ_j) _j^-1( p- μ_j)≤τ, (3) where τ is a tunable threshold (typically τ≈9τ\!≈\!9, corresponding to the 99% confidence contour of a 2D Gaussian). This hash-based approach reduces the association complexity from O(Ngauss×Nevent)O(N_gauss× N_event) to an efficient O(Ngauss×K)O(N_gauss× K), where NgaussN_gauss is the number of visible Gaussians in the current frame, NeventN_event is the number of events in [tst,ted][t_st,t_ed], and K is the small average events returned per Gaussian by the grid query. Motion Statistics. For each Gaussian gjg_j, we estimate its local motion statistics from the associated event set ℰjE_j on the image plane. Specifically, we first compute a polarity-weighted average displacement of events relative to the Gaussian center: j v_j =∑ei∈ℰjpi(i−^j)∑ei∈ℰj|pi|+ε, = _e_i _jp_i\,(x_i- μ_j) _e_i _j|p_i|+ , (4) νj _j =∥j∥,ϕj=atan2(vy,vx), =\| v_j\|, _j=atan2(v_y,v_x), where pi∈−1,+1p_i∈\-1,+1\ is the polarity and i∈ℝ2x_i ^2 is the 2D spatial coordinate of event eie_i, ^j μ_j is the projected 2D mean of Gaussian gjg_j, and ε is a small constant to avoid division by zero. The resulting vector j v_j represents the dominant local motion flow: events with opposite polarities moving in the same direction reinforce each other, while inconsistent noise cancels out. We use its magnitude νj _j as the estimated motion speed and its angle ϕj _j as the motion direction. Fig. 3: Qualitative comparison of reconstructed scenes under severe motion blur conditions. The top three rows show results from state-of-the-art baselines: Photo-SLAM [8], Mono-GS [13], and EGS-SLAM [4]. Photo-SLAM and Mono-GS struggle significantly, producing highly blurry and distorted reconstructions with numerous artifacts and ”ghosting” effects. EGS-SLAM, while benefiting from event data, still exhibits noticeable blur and less accurate details, particularly in fine textures (e.g., the television screen, object edges). In stark contrast, the bottom row showcases results from MotionGS-SLAM (Ours). Our method consistently reconstructs sharp, high-fidelity scenes with clear details and accurate geometry. Event-Modulated Gaussian Kernel The computed motion statistics (ϕj,νj)( _j, _j) drive our dual-modulation kernel, which adapts both the spatial and temporal aspects of the rendering process for each Gaussian. Our approach separates the true 3D geometry from motion blur effects through a two-component covariance design, ensuring the core 3D map remains geometrically accurate while enabling physics-based blur synthesis. Spatial Kernel Modulation. To model the spatial characteristics of motion blur, we construct a motion-aligned prior covariance from event measurements: j,prior2D ^2D_j,prior =(ϕj)diag(σ⟂2,κj2σ⟂2)(ϕj)⊤, =R( _j)\;diag\! ( _ ^2,\ _j^2 _ ^2 )\;R( _j) , (5) κj _j =1+βνj, =1+β _j, where (⋅)R(·) is the 2D rotation matrix, σ⟂2 _ ^2 is a base variance, and κj _j is a velocity-dependent stretch factor. This formulation creates an anisotropic Gaussian aligned with the motion direction ϕj _j and elongated proportionally to the velocity νj _j, replicating the characteristic streak pattern of motion blur. We enforce this motion-consistent shape through a regularization loss: ℒshape=1|vis|∑j∈vis‖^j2D−j,prior2D‖F2,L_shape= 1|G_vis| _j _vis \| ^2D_j- ^2D_j,prior \|_F^2, (6) where ^j2D ^2D_j is the projected 2D covariance of the optimized 3D Gaussian, and visG_vis is the set of Gaussians visible in the current frame. To maintain numerical stability while separating geometry from blur, we decompose the 3D covariance as: j _j =base,j+Δj, = _base,j+ _j, (7) base,j _base,j =(qj)diag(eℓx,j,eℓy,j,eℓz,j)(qj)⊤, =R(q_j)diag(e _x,j,e _y,j,e _z,j)R(q_j) , where base,j _base,j encodes the static 3D geometry with guaranteed positive-definiteness through exponential parameterization, and Δj _j represents the motion-induced deformation bounded via activation functions. This decomposition ensures that motion blur modeling does not corrupt the underlying geometric representation the optimizer learns Δj _j indirectly through the shape prior (Eq. (6)) while maintaining photometric consistency. Temporal Kernel Modulation (Adaptive Sampling). Motion blur arises from integrating light over the exposure interval, during which both the camera and scene features move continuously. To accurately model this process, we adaptively sample the camera trajectory based on the aggregate motion characteristics of all visible Gaussians. For each frame m, we determine the trajectory sampling density by considering the motion statistics across all Gaussians: ν¯m=1|vis|∑j∈visνj, ν_m= 1|G_vis| _j _vis _j, (8) where visG_vis denotes the set of visible Gaussians and ν¯m ν_m represents the scene’s average motion magnitude. This aggregate motion drives our adaptive sampling strategy: Nm=clamp(round(n0⋅(1+α⋅ν¯m⋅Δtm)),Nmin,Nmax),N_m=clamp\! (round\! (n_0·(1+α· ν_m· t_m) ),N_ ,N_ ), (9) where n0n_0 is the base sampling rate, α scales the motion response, Δtm t_m is the exposure duration, and the result is clamped to [Nmin,Nmax][N_ ,N_ ] for computational efficiency. As illustrated in the Fig. 2, this mechanism creates a motion-aware sampling of the camera trajectory: rapid scene motion (high ν¯m ν_m) triggers denser sampling to capture the complex blur formation, while slow or static scenes require fewer samples. The camera poses are then uniformly distributed along the SE(3) geodesic between stT_st and edT_ed: tk=tst+k⋅ΔtmNm−1,k∈0,1,…,Nm−1,t_k=t_st+k· t_mN_m-1, k∈\0,1,...,N_m-1\, (10) ensuring accurate physical simulation of the exposure process while maintaining computational efficiency. Blur Aware Tracking Optimization The tracking front-end is the workhorse of our SLAM system, responsible for estimating the camera’s precise motion for each incoming blurry frame. Its goal is to find the most probable continuous trajectory, parameterized by the exposure start and end poses (st,ed)(T_st,T_ed). To achieve this, for each incoming blurry frame m, we estimate the exposure endpoints (st,ed)(T_st,T_ed) by minimizing minst,edℒphoto+λevtℒLI, _T_st,T_edL_photo+ _evtL_LI, (11) where λevt _evt balances the event terms. 1. Photometric Loss. The foundational constraint of our optimization is photometric consistency. This principle dictates that our model encompassing both the 3D scene representation and the estimated camera trajectory must accurately replicate the physical image formation process. Consequently, the blurred image synthesized by our renderer should closely align with the actual image captured by the camera sensor. To enforce this, we synthesize a blurred image ¯m C_m using our physics-based renderer, complete with the event-modulated spatial and temporal kernels. We then define the photometric loss as a robust error metric (e.g., Charbonnier loss ρ) between our rendered output and the observation obsI_obs: ℒphoto=‖¯m−obs‖ρ,L_photo=\| C_m-I_obs\|_ρ, (12) where ¯m C_m is rendered with per-Gaussian adaptive temporal samples nj(m)n_j^(m) and spatial modulation j,prior2D ^2D_j,prior. 2. Event Alignment Loss. The event camera tells us exactly where and when brightness changed. Our estimated camera motion must be able to reproduce these same brightness changes in the rendered 3D scene. This loss directly aligns the rendered intensity changes with the observed events. Following the event generation model, an event’s polarity pi∈+1,−1p_i∈\+1,-1\ should correspond to the sign of the logarithmic intensity change. We penalize any deviation from this model: ℒLI=∑ei∈ℰρ(pi−logI(ti)−logI(ti−δ)θ),L_LI= _e_i ρ\! (p_i- I(t_i)- I(t_i-δ)θ ), (13) where I(t)I(t) is the rendered intensity at an event’s timestamp tit_i, δ is a small temporal offset, and θ is the event camera’s contrast threshold. This provides strong geometric constraints, especially in visually ambiguous or low-texture regions. I-C Mapping with Keyframe Management While the tracker estimates frame-to-frame motion, the mapping back-end ensures long-term map consistency. It operates on a sliding window of keyframes to jointly refine 3D Gaussians and camera poses, maintaining physical agreement between all sensor observations over time. I-C1 Keyframe Selection We insert a new keyframe when either: (1) the view overlap with the latest keyframe measured as IoU of visible Gaussians drops below τoverlap _overlap, or (2) camera translation exceeds τtrans⋅d¯ _trans· d (where d¯ d is average scene depth). When the keyframe limit is reached, we remove the keyframe with highest neighbor overlap to preserve view diversity while bounding computation. TABLE I: Rendering performance comparison on EventReplica. “–” indicates sequences where reinitialization did not succeed. Boldface marks the best result per column. Method Metric room0 room1 room2 office0 office1 office3 office4 Avg. Rendering FPS PhotoSLAM [8] PSNR[dB]↑ 17.91 18.96 – 23.15 – 17.04 14.28 – 1058.6 SSIM↑ 0.499 0.588 – 0.640 – 0.596 0.546 – LPIPS↓ 0.460 0.455 – 0.417 – 0.391 0.526 – MonoGS [13] PSNR[dB]↑ 20.27 21.77 23.85 26.55 26.56 21.21 21.59 23.12 1102.1 SSIM↑ 0.612 0.677 0.748 0.769 0.810 0.729 0.749 0.728 LPIPS↓ 0.474 0.471 0.355 0.385 0.355 0.287 0.411 0.391 EGS-SLAM [4] PSNR[dB]↑ 24.06 26.30 27.61 31.72 33.38 26.50 23.79 27.62 1168.3 SSIM ↑ 0.744 0.783 0.838 0.885 0.927 0.846 0.806 0.833 LPIPS↓ 0.229 0.256 0.172 0.142 0.123 0.113 0.242 0.182 MotionGS-SLAM (Ours) PSNR[dB]↑ 24.55 27.05 28.22 32.31 33.92 26.98 24.10 28.05 1189.7 SSIM ↑ 0.756 0.796 0.848 0.893 0.933 0.855 0.814 0.842 LPIPS↓ 0.214 0.241 0.159 0.131 0.116 0.107 0.232 0.171 I-C2 Bundle Adjustment The core of our mapping process is a bundle adjustment over the sliding window W, where we jointly optimize the Gaussian map G and the keyframe poses \T\ using a comprehensive, blur-consistent objective: min, _G,\T\ ∑w∈[ℒphotow+λevtℒLIw] _w [L_photo^w+ _evtL_LI^w ] (14) +λshapeℒshape, + _shapeL_shape, where W is the set of keyframes in the current optimization window. This objective has two main parts: Data Consistency Terms: The first summation, ∑w∈[…] _w […], ensures that for every keyframe in the window, our optimized map and poses can accurately reproduce the observed blurry images and event streams. This enforces consistency across time. ℒshapeL_shape: Image-Plane Shape Prior Loss. This loss encourages each 3D Gaussian, after projection onto the image plane, to form a 2D elliptical kernel slightly elongated along the detected motion direction, without altering its underlying 3D geometry. It is defined in Eq. (6): if events detect motion in a certain direction, the projected Gaussian ellipse is encouraged to be gently elongated along that direction; otherwise, it remains isotropic. This enforces a physically meaningful explanation of blur while avoiding contaminating the underlying 3D geometry. IV Experiments In this section, we conduct a series of rigorous experiments to validate the effectiveness of MotionGS-SLAM. IV-A Datasets and Metrics Datasets: We evaluate our method on both synthetic and real-world sequences to ensure a thorough analysis. EventReplica: We created a challenging synthetic dataset by adapting the Replica dataset [18]. For each camera trajectory, we render a high number of intermediate frames and simulate a long exposure by averaging them, which produces significant and physically realistic motion blur. To simulate low-light-induced motion blur conditions, we also inject Poisson-Gaussian noise into the final blurred images. This dataset provides ground truth sharp images for objective evaluation of reconstruction quality. Event streams are synthesized via ESIM [17] using a balanced threshold Θ=0.2 =0.2 and monochrome events. Real Database: To test our system in real-world scenarios, we introduce a real-world dataset of 33 indoor/outdoor scenes recorded with a Color-DAVIS346 [19] camera. This device captures both color frames at 346×260346× 260 resolution and color events. We capture 3 challenging scenes using a handheld camera setup under low-light conditions. Each scene contains rich textures and color information. For each scene, we acquire 30s frames across multiple viewpoints with varying degrees of motion blur, along with temporally aligned event streams recorded by the event camera. Metrics: We use standard metrics for evaluation. For trajectory accuracy, we report the Absolute Trajectory Error (ATE) [cm]. For mapping quality on the synthetic dataset, we report PSNR, SSIM, and LPIPS [24]. IV-B Implementation Details Our system is implemented in PyTorch and runs on a single NVIDIA RTX 4080 GPU. We build our system upon the MonoGS [13] codebase. For our event-modulated kernel, we set the base temporal samples n0=9n_0=9 and the spatial stretch factor control β=0.05β=0.05. In our loss function, weights are set to λevt=2.0 _evt=2.0, λphoto=1.0 _photo=1.0, and λshape=0.2 _shape=0.2. For all comparisons, we ensure that competing methods are configured to their official recommended settings for a fair evaluation. In all tables, boldface indicates the best result. IV-C Comparison with State-of-the-Art Evaluation on Blurry-Replica with Event (Synthetic) We compare MotionGS-SLAM against representative baselines on the challenging EventReplica benchmark under low-light and long-exposure settings: the photometric SLAM PhotoSLAM [8], the image-only GS-SLAM MonoGS [13], and the event-guided EGS-SLAM. We evaluate two aspects: (i) reconstruction fidelity, and (i) tracking accuracy under severe motion blur. Reconstruction quality and throughput. Table I reports PSNR/SSIM/LPIPS and rendering FPS. While PhotoSLAM and MonoGS degrade notably with persistent blur, and EGS-SLAM improves upon image-only pipelines by utilizing events, MotionGS-SLAM achieves the best fidelity across almost all sequences and the highest rendering FPS. Concretely, MotionGS-SLAM improves the average PSNR from 23.12 dB (MonoGS) and 27.62 dB (EGS-SLAM) to 28.05 dB; SSIM from 0.728 (MonoGS) and 0.833 (EGS-SLAM) to 0.842; and LPIPS from 0.391 (MonoGS) and 0.182 (EGS-SLAM) down to 0.171. On representative sequences, our PSNR is higher (e.g., office1: 33.92 vs. 33.38; office0: 32.31 vs. 31.72; room1: 27.05 vs. 26.30). Throughput-wise, MotionGS-SLAM reaches 1189.7 FPS, exceeding EGS-SLAM (1168.3), MonoGS (1102.1), and PhotoSLAM (1058.6), indicating that event-modulated spatial/temporal kernels not only sharpen reconstructions but also preserve rendering speed. Fig. 4: Qualitative comparison on our real-world dataset. We demonstrate our method’s performance on challenging, low-light handheld sequences. As shown in the corresponding figure, image-only baselines like Photo-SLAM [8] and Mono-GS [13] produce blurry reconstructions with severe ”ghosting” artifacts. While the event-based EGS-SLAM [4] improves upon them, it still suffers from soft details. In contrast, our method is the only one that successfully reconstructs a sharp, geometrically consistent scene, recovering fine details. Tracking accuracy. As shown in Table I, MotionGS-SLAM achieves the lowest ATE in all seven sequences. ORB-SLAM2 and PhotoSLAM frequently lose tracking as blurred edges hamper keypoint detection; MonoGS assumes blur-free inputs and suffers on long-exposure frames. EGS-SLAM benefits from events but lacks our exposure-integration modeling and per-Gaussian modulation, leading to consistently higher errors. Overall, MotionGS-SLAM reduces the average ATE from 9.22 cm (MonoGS) to 4.44 cm (∼ 51.9% improvement), and further improves over EGS-SLAM (5.17 cm) by ∼ 14.2%. These numbers exactly correspond to the averages reported in Table I. Evaluation on Real-World Data We further validate our method on three challenging, low-light handheld scenes. As shown in Table I, the event-based EGS-SLAM is the strongest baseline, significantly outperforming image-only methods. TABLE I: Tracking Accuracy (ATE in cm) and Ablation Study on our Real-World Dataset. Method Scene 1 Scene 2 Scene 3 Avg. Comparison with State-of-the-Art ORB-SLAM3 [2] 8.91 35.42 41.05 28.46 PhotoSLAM [8] 11.24 9.85 28.66 16.58 EGS-SLAM [4] 4.52 5.15 4.81 4.83 Ablation Study Baseline (MonoGS) [13] 6.88 7.12 5.95 6.65 + Events 4.65 5.01 4.42 4.69 + Spatial Modulation 4.03 4.45 3.88 4.12 Full Model (Ours) 3.45 4.02 3.18 3.55 TABLE I: Tracking results ATE (cm) on EventReplica. L denotes tracking failure. Boldface marks the best result per row/average. Scenes ORB-SLAM2 [14] PhotoSLAM [8] MonoGS [13] EGS-SLAM [4] MotionGS-SLAM room0 5.57 6.64 12.76 4.85 3.98 room1 L L 8.45 3.55 2.88 room2 L L 3.64 3.25 2.84 office0 L L 7.44 3.75 3.01 office1 L L 7.78 3.66 3.06 office3 6.48 6.78 7.91 4.55 3.92 office4 L L 16.55 12.60 11.37 Avg. – – 9.22 5.17 4.44 Qualitative Results: Fig.3 and Fig.4 provide a visual comparison of the reconstructed maps. The outputs from MonoGS are visibly blurry and contain significant floating artifacts and ”ghosting” effects, consistent with the quantitative results. In contrast, our reconstruction is sharp, detailed, and geometrically coherent, highlighting the power of our physics-based, event-guided rendering approach. IV-D Ablation Study To rigorously validate our design choices, we conduct a detailed ablation study on two representative EventReplica sequences. We analyze how each component of our event-guided framework contributes to the final performance. The results are summarized in Table IV and shown in Fig. 5. Our ablation compares five system variants: A0 (Baseline): A standard GS-SLAM system (MonoGS) using only the blurry images, with no event data or explicit blur model. A1 (Blur Model Only): Augments the baseline with our physics-based exposure integration renderer, but without any guidance from events. A2 (Event Assoc.): Introduces event data and association but does not yet use it to modulate the rendering kernel. Events contribute only through standard losses (ℒLIL_LI. A3 (Spatial Modulation Only): Builds on A2 by adding our spatial kernel modulation (anisotropic deformation via ℒshapeL_shape), but keeps temporal sampling fixed. A4 (Temporal Modulation Only): Builds on A2 by adding our adaptive temporal sampling, but keeps the spatial kernel untouched. A5 (Full / Ours): The complete MotionGS-SLAM system with both spatial and temporal modulation enabled. TABLE IV: Ablation on EventReplica for two scenes. Best results in each column are in bold. Variant room0 office0 ATE↓ PSNR↑ SSIM↑ LPIPS↓ ATE↓ PSNR↑ SSIM↑ LPIPS↓ A0_Baseline 12.76 20.27 0.612 0.474 7.44 26.55 0.769 0.385 A1_Blur_Only 11.80 21.10 0.630 0.455 6.90 27.30 0.780 0.370 A2_Event_Assoc 6.10 22.20 0.700 0.340 4.10 28.50 0.830 0.240 A3_Spatial_Only 5.40 23.60 0.735 0.250 3.50 30.70 0.880 0.160 A4_Temporal_Only 5.10 23.10 0.725 0.265 3.40 30.20 0.870 0.175 A5_Full (Ours) 3.98 24.55 0.756 0.214 3.01 32.31 0.893 0.131 The Necessity of Event Data The results in Table IV reveal the critical role of event cameras in addressing motion blur. The baseline (A0) fails catastrophically with blur-only inputs, while simply adding our physics-based blur model (A1) provides marginal gains reducing ATE from 12.76cm to 11.80cm on room0. The breakthrough comes with event integration (A2): ATE plummets to 6.10cm, a 52% reduction from baseline. This dramatic improvement demonstrates that events provide the missing temporal resolution needed to disambiguate motion during exposure. However, A2’s relatively poor perceptual metrics (LPIPS of 0.340 vs. our full model’s 0.214) exposes a crucial limitation: standard event losses alone cannot solve the rendering problem. They constrain camera motion but fail to inform how blur should be synthesized. Dissecting the Dual-Modulation Kernel Comparing variants A2 through A5 validates our core hypothesis: effective blur handling requires modeling both its spatial formation and temporal integration. Spatial modulation (A3) transforms the reconstruction quality LPIPS improves from 0.340 to 0.250 on room0, the single largest perceptual gain across all components. This confirms our insight that event-guided anisotropic deformation correctly models the physical ”painting” of motion streaks. Temporal modulation (A4) contributes differently but equally importantly: it ensures photometric accuracy by adapting the exposure integral’s sampling density to local motion, improving PSNR while maintaining computational efficiency. The full model (A5) demonstrates clear synergy: combining both modulations yields the best performance across all metrics (ATE: 3.98cm, PSNR: 24.55dB, LPIPS: 0.214), surpassing either component alone. This validates our paradigm shift rather than attempting to invert blur, we must model both how blur spatially manifests and how it temporally accumulates to achieve robust SLAM under severe motion. Fig. 5: Qualitative Ablation Study on EventReplica Dataset. Top row shows severely blurred input. Red and orange boxes highlight reconstructed details for: A2: Event data with standard losses. A3: A2 + spatial kernel modulation. A5 (Ours): Complete MotionGS-SLAM. Clear progression from blurry A2 to sharp A3, culminating in high-fidelity reconstruction with our full model. V Summary We introduce MotionGS-SLAM, a robust SLAM system that excels in high-motion scenarios by fundamentally shifting the approach to motion blur. Instead of treating blur as an artifact to be corrected, we reformulate it as a physical process to be generatively modeled within the rendering pipeline. Our central contribution is a novel event-modulated Gaussian kernel, which leverages high-frequency event data to guide this physics-based synthesis. By transforming blur from a challenge into a supervisory signal, our method achieves state-of-the-art tracking accuracy and sharp scene reconstruction directly from severely degraded images. References [1] G. Bae, C. Choi, H. Heo, S. M. Kim, and Y. M. Kim (2024) I 2-slam: inverting imaging process for robust photorealistic dense slam. In European Conference on Computer Vision, p. 72–89. Cited by: §I-A. [2] C. Campos, R. Elvira, J. J. G. Rodríguez, et al. (2021) Orb-slam3: an accurate open-source library for visual, visual–inertial, and multimap slam. IEEE Trans. Robot. 37 (6), p. 1874–1890. Cited by: §I, TABLE I. [3] M. Cannici and D. Scaramuzza (2024) Mitigating motion blur in neural radiance fields with events and frames. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 9286–9296. Cited by: §I-B. [4] S. Chen, S. Yuan, T. Nguyen, Z. Huang, C. Shi, J. Jing, and L. Xie (2025) EGS-slam: rgb-d gaussian splatting slam with events. IEEE Robotics and Automation Letters. Cited by: Fig. 3, TABLE I, Fig. 4, TABLE I, TABLE I. [5] T. Deng, Y. Chen, L. Zhang, J. Yang, S. Yuan, J. Liu, D. Wang, H. Wang, and W. Chen (2024) Compact 3d gaussian splatting for dense visual slam. arXiv preprint arXiv:2403.11247. Cited by: §I-A. [6] Z. Fan, J. Zhang, W. Cong, P. Wang, R. Li, K. Wen, S. Zhou, A. Kadambi, Z. Wang, D. Xu, et al. (2024) Large spatial model: end-to-end unposed images to semantic 3d. Advances in neural information processing systems 37, p. 40212–40229. Cited by: §I-A. [7] H. Han, J. Li, H. Wei, and X. Ji (2024) Event-3dgs: event-based 3d reconstruction using 3d gaussian splatting. Advances in Neural Information Processing Systems 37, p. 128139–128159. Cited by: §I-B. [8] H. Huang, L. Li, H. Cheng, and S. Yeung (2024) Photo-slam: real-time simultaneous localization and photorealistic mapping for monocular stereo and rgb-d cameras. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 21584–21593. Cited by: Fig. 3, TABLE I, Fig. 4, §IV-C, TABLE I, TABLE I. [9] N. Keetha, J. Karhade, K. M. Jatavallabhula, G. Yang, S. Scherer, D. Ramanan, and J. Luiten (2024) Splatam: splat track & map 3d gaussians for dense rgb-d slam. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 21357–21366. Cited by: §I, §I-A. [10] B. Kerbl, G. Kopanas, T. Leimkühler, and G. Drettakis (2023) 3D gaussian splatting for real-time radiance field rendering.. ACM Trans. Graph. 42 (4), p. 139–1. Cited by: §I, §I-A. [11] M. Li, S. Liu, H. Zhou, G. Zhu, N. Cheng, T. Deng, and H. Wang (2024) Sgs-slam: semantic gaussian splatting for neural dense slam. In European Conference on Computer Vision, p. 163–179. Cited by: §I-A. [12] L. Ma, X. Li, J. Liao, et al. (2022) Deblur-nerf: neural radiance fields from blurry images. In Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit., p. 12861–12870. Cited by: §I. [13] H. Matsuki, R. Murai, P. H. Kelly, and A. J. Davison (2024) Gaussian splatting slam. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 18039–18048. Cited by: §I, §I-A, Fig. 3, TABLE I, Fig. 4, §IV-B, §IV-C, TABLE I, TABLE I. [14] R. Mur-Artal and J. D. Tardós (2017) Orb-slam2: an open-source slam system for monocular, stereo, and rgb-d cameras. IEEE Trans. Robot. 33 (5), p. 1255–1262. Cited by: TABLE I. [15] Y. Qi, L. Zhu, Y. Zhang, and J. Li (2023) E2nerf: event enhanced neural radiance fields from blurry images. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 13254–13264. Cited by: §I-B. [16] D. Qu, C. Yan, D. Wang, J. Yin, et al. (2024) Implicit event-rgbd neural slam. In Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit., p. 19584–19594. Cited by: §I-B. [17] H. Rebecq, D. Gehrig, and D. Scaramuzza (2018) Esim: an open event camera simulator. In Conference on robot learning, p. 969–982. Cited by: §IV-A. [18] J. Straub, T. Whelan, L. Ma, Y. Chen, E. Wijmans, S. Green, J. J. Engel, R. Mur-Artal, C. Ren, S. Verma, et al. (2019) The replica dataset: a digital replica of indoor spaces. arXiv preprint arXiv:1906.05797. Cited by: §IV-A. [19] G. Taverni, D. P. Moeys, C. Li, C. Cavaco, V. Motsnyi, D. S. S. Bello, and T. Delbruck (2018) Front and back illuminated dynamic and active pixel vision sensors comparison. IEEE Transactions on Circuits and Systems I: Express Briefs 65 (5), p. 677–681. Cited by: §IV-A. [20] Z. Teed and J. Deng (2021) Droid-slam: deep visual slam for monocular, stereo, and rgb-d cameras. Advances in neural information processing systems 34, p. 16558–16569. Cited by: §I. [21] T. Xiong, J. Wu, B. He, C. Fermuller, Y. Aloimonos, H. Huang, and C. A. Metzler (2024) Event3dgs: event-based 3d gaussian splatting for high-speed robot egomotion. arXiv preprint arXiv:2406.02972. Cited by: §I-B. [22] C. Yan, D. Qu, D. Xu, B. Zhao, Z. Wang, D. Wang, and X. Li (2024) Gs-slam: dense visual slam with 3d gaussian splatting. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 19595–19604. Cited by: §I, §I-A. [23] W. Yu, C. Feng, J. Li, J. Tang, J. Yang, Z. Tang, M. Cao, X. Jia, Y. Yang, L. Yuan, et al. (2025) Evagaussians: event stream assisted gaussian splatting from blurry images. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 24780–24790. Cited by: §I-B. [24] R. Zhang, P. Isola, A. A. Efros, E. Shechtman, and O. Wang (2018) The unreasonable effectiveness of deep features as a perceptual metric. In Proceedings of the IEEE conference on computer vision and pattern recognition, p. 586–595. Cited by: §IV-A.