Change-Aware Loop Closure for Gaussian SLAM in Rearranged Scenes

Long-running mapping systems fix accumulated drift by recognizing a place they have seen before and pulling the trajectory back into agreement with it. This is loop closure, and it feeds a pose graph optimizer: a least-squares solver that treats camera poses as nodes and measured relative motions as springs between them. Every loop-closure spring rests on one assumption. Whatever looks different between the first visit and the revisit is the camera's fault, not the world's. Real environments break that assumption in a quiet way. A person walks through the frame, which current dynamic-scene systems already handle. More damaging is the box that was moved, the chair pushed in, or the door now open. These objects sit still during each visit, so motion masks never flag them, yet they have changed between visits. When a loop registration aligns two submaps that disagree about where the box is, it bends the camera estimate to partly explain the box's displacement. The result is a loop edge that is wrong by a few centimetres or degrees but looks plausible.

We propose a change-aware loop registration for 3D Gaussian Splatting SLAM (maps made of many small colored 3D Gaussian blobs that can be rendered differentiably). When two submaps are registered at a loop candidate, the method jointly estimates one camera correction plus a small set of independent rigid motions for object segments that relocated between visits. A description-length penalty keeps the segment set small. Only the part of the discrepancy explained by the camera enters the pose graph, and its confidence is scaled by how much static background actually supported it. The relocated segments are not thrown away. They become object-level updates to the map. The core claim is testable: under between-visit rearrangement, this registration produces loop edges with lower bias than either masking or robust down-weighting, and therefore lower final trajectory error. It does so without giving up the loop closures that robust methods discard.

Where the gap actually is

The research file shows two families that do not meet. The first closes loops by registering explicit Gaussian geometry. LoopSplat renders one submap from the viewpoint of an overlapping one and minimizes photometric and depth residuals to get a relative pose edge. GLC-SLAM anchors Gaussian submaps to keyframes and deforms them right after pose graph optimization. CP-SLAM does the same with keyframe-anchored neural points. All three assume a static world, and GLC-SLAM names dynamic handling as open work. These papers supply our map representation and pose graph backend.

The second family handles dynamics but has no global backend. DG-SLAM builds motion masks by warping depth across a sliding window and combining the result with semantic priors. It explicitly lists the lack of loop closure and pose graph optimization as a limitation. D2GSLAM models moving objects with 4D Gaussians but optimizes only locally. RoDyn-SLAM combines semantic and epipolar flow masks. ROS-Cam down-weights dynamic points with learned heavy-tailed uncertainty. On the monocular side, 4D3R and Free-DyGS are pose-free dynamic reconstructions that use only local or sequential refinement. VGGT-Motion has submap-level pose graph optimization but reports that crowded dynamics contaminate its geometric priors. These papers motivate the work.

The obvious combination is to put DG-SLAM's masks in front of LoopSplat's registration. That handles objects moving while the camera watches. It does not handle the case this proposal targets. Every one of these masking mechanisms detects inconsistency within a short time window, whether through depth warping across neighbouring keyframes, flow against epipolar geometry, semantic class, or per-point residual over a batch. A relocated object is consistent within every window and inconsistent only across the loop. The camera's pose estimate for the loop edge therefore depends on a staticness assumption that local masking cannot check. That is the specific way "camera pose dependency" and the "static scene assumption" interact inside pose graph optimization, and it is what we target.

Core mechanism

At a loop candidate between submaps $A$ and $B$, found by NetVLAD place recognition as in LoopSplat, we first cluster $B$'s Gaussians into spatially compact segments. The clusters come from geometry plus a class-agnostic segmenter. We then solve

$$ \min_{T,\;\{M_k\},\;\{z_k\}} \; \sum_{k} \rho\!\left(r_k\!\left(T,\, M_k^{z_k}\right)\right) \;+\; \lambda \sum_k z_k , $$

The symbols are defined as follows. $T \in SE(3)$ is the relative camera correction that becomes the loop edge. $M_k \in SE(3)$ is an extra rigid motion for segment $k$. $z_k \in \{0,1\}$ indicates whether segment $k$ relocated: when $z_k = 0$, the motion $M_k$ is the identity. $r_k$ is the rendered photometric and depth residual of segment $k$'s Gaussians, re-rendered into $A$'s keyframes after applying $T$ and then $M_k$. $\rho$ is a robust loss. $\lambda$ is the description-length price of declaring a segment moved.

The penalty matters. Without it, every segment could absorb camera error. With it, a segment is declared moved only when it explains substantially more residual than the camera correction alone. We solve by alternating differentiable rendering, which LoopSplat already uses, with a greedy add or remove step on the $z_k$. We seed candidate $M_k$ from each segment's own best-fit registration.

The edge passed to the pose graph is weighted by a confidence $\Omega_T$, an information matrix built from the Gauss-Newton Hessian over static-labeled residuals only. This means an edge supported by one wall is weaker than one supported by a whole room. If the static support falls below a threshold, the edge is dropped. Relocated segments are re-anchored to the revisit keyframe, so the map holds the object in its current place rather than a ghost at both locations. The record is kept as an object-level change log, which could later be extended to explicit object nodes in the graph.

Research Program

We build on a single front end so that only loop handling differs between systems. For RGB-D, that front end is DG-SLAM-style dynamic tracking with masks and Gaussian alignment. On top we add GLC-SLAM-style submaps with instant Gaussian deformation after pose graph optimization, and LoopSplat-style rendered registration, replaced by the change-aware version above.

The first analysis is diagnostic, and it can be done before any method building. On sequences with controlled rearrangement, we measure the bias of standard LoopSplat edges against ground-truth relative poses as a function of the image fraction occupied by relocated objects. We also record whether robust pose graph kernels flag those edges as outliers. The proposal depends on finding a band of contamination where edges are biased yet still pass robust tests. If that band does not exist, the simpler robust-kernel answer suffices, and we would say so.

As a secondary extension, we replace the RGB-D front end with VGGT-Motion's monocular submaps and Sim(3) alignment. Sim(3) means alignment up to rotation, translation, and an unknown scale. This tests whether the same registration helps calibration-free monocular mapping, where the authors report dynamic contamination.

Baselines

The naive reference is the shared dynamic front end with no loop closure. It is effectively DG-SLAM, which reports an average ATE (absolute trajectory error, the root-mean-square distance between estimated and true camera positions) of 5.5 cm on BONN (DG-SLAM). We will rerun it rather than copy the number, because loop-rich sequences are needed. This reference tells us whether loops help at all under dynamics.

The strongest existing method for global consistency is LoopSplat registration with pose graph optimization, run unmodified on our shared front end. LoopSplat reports a 33% ATE improvement over prior Gaussian methods on ScanNet++ (LoopSplat). No reported result was found on Lacuna for LoopSplat or GLC-SLAM on BONN or on any rearranged-scene benchmark.

The strongest straightforward fix is LoopSplat with DG-SLAM masks applied before registration, plus a robust kernel in the pose graph. The robust kernel down-weights or switches off edges with large residuals. All loop variants use identical NetVLAD candidates, the same Gaussian submaps, the same number of registration iterations, and the same GPU budget. Each gets an equal hyperparameter sweep on a held-out Replica rearrangement split.

The ablation that isolates our key ingredient keeps everything except the per-segment motions. Segments can only be down-weighted, ROS-Cam style with Cauchy weights, and never explained as moved. This separates "explain away" from "ignore." We count it as beating these baselines if the method meets three conditions. It must reduce ATE relative to mask-plus-robust LoopSplat on rearranged sequences. It must retain more true loop edges. It must not lose accuracy on static ScanNet++ and Replica, where GLC-SLAM's reported Replica PSNR (peak signal-to-noise ratio of rendered images) of 41.07 (GLC-SLAM) serves as a rendering sanity reference.

Why not just…?

Why not just use a robust kernel in the pose graph and let it reject bad loops? This is the most serious alternative. If contaminated edges are grossly wrong, a robust kernel will reject them, and our machinery adds little. Our concern is twofold. Partial contamination produces biased edges whose residuals are small enough to pass. And when the loop at a revisit is the only loop, rejecting it leaves the drift in place. The diagnostic study measures both effects directly. If robust rejection matches our ATE across contamination levels, we will report the idea as unnecessary.

Why not just mask dynamic pixels before registering, as DG-SLAM or RoDyn-SLAM do? Those masks come from depth warping in sliding windows, epipolar flow, or semantics (DG-SLAM, RoDyn-SLAM). A box at rest during both visits triggers none of these cues, and semantic masks also miss unseen classes, as the file notes for balloons and boxes. The mask-plus-LoopSplat baseline tests this directly on sequences where the only change is a relocation.

Why not just learn per-point uncertainty and down-weight residuals, as ROS-Cam does? Down-weighting discards the relocated object's evidence instead of using it. A large relocated object also pulls the robust optimum toward a compromise pose, because many coherent points disagree together. ROS-Cam itself reports failure when moving content dominates the frame (ROS-Cam). Our uncertainty-only ablation is exactly this alternative inside the same system.

Proposed Experiments

The decisive benchmark is a rearranged-Replica suite that we construct. Each scene is rendered along a looping trajectory, with K objects moved between the outbound and return passes. K ranges from 0 to about 6, and image coverage of moved objects is varied. Ground-truth poses and object displacements are exact, so we can report three measures: loop-edge bias in rotation and translation, retained-edge recall, and final ATE.

The real-world tests are BONN dynamic sequences, whose box-moving sequences contain genuine between-visit relocation, and TUM f3 walking sequences. RoDyn-SLAM's 8.3 cm on f3/wk_xyz serves as a reported reference point. We report ATE, and on BONN also Depth L1 and completion ratio against the static ground-truth scans. Ghost-free maps should show up as lower Depth L1 at relocated-object locations. Static ScanNet++ checks for regression.

The key decisive check is the plot of edge bias against moved-object coverage for four systems: LoopSplat, mask-plus-robust, uncertainty-only, and ours. The proposal succeeds if ours keeps bias near the static level in the middle band, where the others are biased but not rejected. If the diagnostic finds no such band, the honest conclusion is that robust pose graph optimization already suffices, and the work shifts to the map-update side alone.