A camera-only mapping system tracks its own motion one frame at a time, and small errors pile up. Two kinds of error matter here. The first is ordinary drift in position and heading. The second is specific to a single camera: the system cannot measure absolute size, so the scale of the map slowly wanders. The standard repair is loop closure. When the camera returns to a place it has seen before, the system estimates how the old and new views relate, including a relative scale factor, and spreads the correction back over the whole trajectory. That estimate assumes the place looks the same on both visits. Real places do not. Between visits a parked car leaves, chairs get moved, a crowd thins out. Recent work handles things that move during a visit. Nothing in the literature we found handles things that changed between visits, and that is the case that corrupts the loop-closure scale estimate.
We propose a loop-closure module that predicts, for every pixel pair in a revisit, whether the surface it shows persisted between the two visits. Only persistent surfaces are allowed to vote on the relative position, rotation and scale. The predictor is trained entirely on synthetic revisits, where object rearrangement and ground-truth scale cost nothing to generate. It runs on frozen real-image features so that it transfers to real cameras. The claim is narrow and testable. Within-visit dynamic filtering combined with a standard loop-closure back end will produce biased scale corrections whenever a revisit contains static-but-changed content. A persistence-weighted estimate removes that bias. The bias should grow with the fraction of changed scene, and the fix should matter most exactly there.
Core Claim
The obvious combination at this intersection is to take a monocular system that suppresses moving objects and attach a scale-aware loop closure to it. For the first part, WildGS-SLAM predicts a per-pixel uncertainty from DINOv2 features and down-weights moving pixels in tracking and mapping. De4D-SLAM separates static and dynamic Gaussians using a stop-gradient on static residuals. For the second part, HI-SLAM uses a 7-degree-of-freedom pose graph to correct rotation, translation and scale. Each part is published separately, and gluing them together is engineering.
Our point is that the glued system has a blind spot built into it. WildGS-SLAM and De4D-SLAM learn which pixels fail to fit the model built within the current session. A car that sat still for the entire first visit fits that model perfectly. It is gone on the second visit, and the wall behind it is now exposed. Neither visit's dynamic filter flags anything, because nothing moved while it was watching. When the loop edge is computed, matched depths on the car region and the newly exposed wall disagree. They disagree systematically, not randomly: the wall sits behind where the car was, so they pull the scale estimate in one direction. Monocular depth priors make this worse. As 2GO does, these systems lift two-view matches to 3D with Metric3Dv2 or MASt3R, and a depth network sees "car at 8 m" and "wall at 12 m" as equally plausible content.
What is new here is treating cross-visit persistence as its own quantity, separate from within-visit motion. We predict it from the image pair alone and use it as the weighting inside the scale-and-pose estimate of each loop edge.
Research Program
The system has three parts, and only the middle one is the contribution.
The front end is WildGS-SLAM, unmodified: uncertainty-weighted dense bundle adjustment (DROID-SLAM's joint optimization of per-pixel depth and camera poses), with a Gaussian-splat map. Loop candidates come from global image retrieval, as in GLC-SLAM and 2GO. We compute retrieval descriptors from features already multiplied by the within-visit uncertainty, so that moving pedestrians do not dominate the descriptor.
The contribution is a persistence predictor. It takes the two keyframes of a candidate loop and their frozen DINOv2 feature maps, and outputs a dense map $p(x) \in [0,1]$. This is the probability that the surface at pixel $x$ of the current frame is the same physical surface seen at the corresponding location in the past frame. The architecture is a small cross-attention head on top of the frozen encoder. We freeze the encoder deliberately, following FAINT. FAINT showed that frozen features pretrained on real images let a policy trained only in simulation reach 90% real-world navigation success, because synthetic and real images land in similar feature geometry. The loop edge is then the scaled rigid transform $(s, R, t)$ that minimizes
$$\sum_x p(x)\,\rho\!\left(\left\| s R\, X_{\text{cur}}(x) + t - X_{\text{past}}(m(x)) \right\|\right).$$
Here $X_{\text{cur}}(x)$ and $X_{\text{past}}(m(x))$ are the 3D points lifted from the matched pixels $x$ and $m(x)$, and $\rho$ is a standard robust loss. The edge also gets an information weight derived from $\sum_x p(x)$. When too little persistent overlap remains, the edge is downgraded to the direction-only "scale-free" type that 2GO already defines, rather than being trusted as a full 7-degree-of-freedom constraint. This directly addresses the tension the file notes: aggressive masking leaves too little overlap to solve for scale. Instead of failing silently, the system says so.
Training data comes from synthetic revisits. We render camera trajectories through the TartanAir environments (TartanAir), reusing its large diversity of camera motions. On a second pass of each trajectory, we apply controlled scene edits: object removal, insertion and displacement, lighting change, and moving actors. The renderer gives exact persistence labels, depth and relative scale. We supervise $p$ directly, and also supervise the resulting $(s, R, t)$ end to end through the weighted solver.
To fight the shortcut learning the file warns about, we use three measures. We apply photometric and sensor augmentation: blur, noise, exposure shifts and rolling shutter. We keep the encoder frozen. And we include "change-free" revisit pairs that contain only sensor and lighting differences, so that noise alone must never lower $p$.
After optimizing the pose graph, the map is corrected in the way GLC-SLAM does, by moving Gaussians with their anchoring keyframe instead of retraining. Because the correction includes scale, it also multiplies Gaussian means and sizes by $s$. Gaussians in regions predicted non-persistent are tagged as belonging to their visit, and are not merged across visits. That keeps the map from fusing a departed car with the wall behind it into a ghost. We keep this map step deliberately simple. It is downstream of the claim, not the claim.
Baselines
The naive reference point is WildGS-SLAM with no loop closure at all. This measures how much drift a loop closure is worth on each sequence. On the WildGS-SLAM MoCap split, this system reports an average ATE RMSE (root-mean-square absolute trajectory error) of 0.46 cm, against 8.71 cm for Splat-SLAM (WildGS-SLAM). Those sequences are short and indoor, so we expect little room for loop closure there. The loop-closure test needs longer, revisiting sequences.
The strongest competitor is the bolt-on system. It uses the WildGS-SLAM front end and computes 2GO-style two-view loop edges (2GO) with MASt3R and with Metric3Dv2 lifting. Within-visit uncertainty masks are applied to both frames. All of this goes into the same pose-graph back end with the same scale-capable edges. This is the strongest competitor because it is exactly what a careful engineer would build from published parts, and it already removes moving objects. On its own odometry setting, 2GO reports reducing ATE from 2.44 m in raw odometry to 0.66 m on a 1.56 km Spot robot sequence. We have no reported result found on Lacuna for any monocular dynamic-scene system with loop closure on our target sequences, so we will run this baseline ourselves.
A second strong competitor is the same bolt-on pipeline with De4D-SLAM's static stream supplying the masks. De4D-SLAM reports 1.95 cm average ATE on Bonn RGB-D Dynamic (De4D-SLAM). It runs at 0.47 FPS, so we run it offline and report time separately.
Fairness rules apply to all of these. Every variant shares the identical front end, loop candidates, matcher, depth network, pose-graph solver and robust-loss settings. The only thing that differs is the per-pixel weight inside the loop-edge solve. Robust-loss and inlier thresholds are tuned on a held-out synthetic split with the same tuning budget for every variant, and nothing is tuned on real test sequences.
Two ablations isolate the key ingredient. The first replaces $p$ with the product of the two visits' within-visit certainties. This tests whether persistence is genuinely a different quantity. The second trains the same head on real data only, using TUM and Bonn sequences with weak labels from depth disagreement. This tests whether the synthetic revisits are what makes it work.
Beating the bolt-on means three things on the change-rich sequences: lower relative-scale error per loop edge, lower final ATE, and no regression on change-free sequences. The scale-error and ATE gaps must be larger than the variation across random seeds.
Why not just…?
Why not just mask cars and people with a segmentation network before loop closure? Category masking removes parked cars that never moved. Those are often the most distinctive geometry at a revisit, and losing them starves the scale estimate. Category masking also misses rearranged furniture, boxes and other objects outside the label vocabulary, as well as cast shadows; DGS-SLAM found it needed a photometric residual check on top of segmentation to catch shadows. We include segment-and-mask as a baseline. We expect it to tie us on scenes where the only change is pedestrians, and to lose where change involves non-person objects or where parked vehicles dominate the view.
Why not just use robust estimation (RANSAC or a heavy-tailed loss) and let the changed pixels fall out as outliers? This is the real threat, and we treat it as such. If persistent surfaces are a clear majority and changed surfaces scatter randomly, a robust solver should already reject them. Our argument is that change is often structured. A displaced car is a self-consistent rigid mode of its own. A removed object exposes background that lies consistently behind it. Either can win the inlier vote once the changed fraction is large. The synthetic benchmark sweeps the changed-area fraction from 0 to 70%. If robust estimation matches our method across that sweep, the persistence predictor is unnecessary, and we will report that the contribution reduces to the benchmark and the diagnosis.
Why not just trust the confidence map that MASt3R already outputs? MASt3R's confidence reflects how well it can match and regress geometry, not whether a surface persisted. A clearly visible car present in only one view can still be matched confidently to background with similar texture. We test this directly by substituting MASt3R confidence for $p$, a third ablation.
Why not train on real data instead of simulation? Real revisit datasets with per-pixel persistence labels and ground-truth relative scale do not exist at scale. DROID-SLAM and FAINT both show that training only in simulation can transfer when the input representation is right. The real-data-only ablation measures how much we lose without synthetic revisits.
Proposed Experiments
The first experiment is the controlled synthetic sweep. We use held-out TartanAir environments with scripted revisits and vary the changed-area fraction and the type of change. Metrics are the per-loop-edge relative-scale error $|\log \hat{s} - \log s|$, the rotation and translation errors of each edge, the final ATE after scaled alignment, and the false-loop acceptance rate. The decisive check is whether the bolt-on system's scale error grows with the changed fraction while ours stays flat. If the bolt-on's error does not grow, the premise is wrong and we stop there.
The second experiment tests real long-range transfer on 4Seasons, which has multi-session revisits of the same routes under real change. VGGT-Motion reports 84–96% ATE reductions there over its baselines (VGGT-Motion). It gives no absolute number in the file, so we rerun it as an additional reference. We add KITTI sequences with loops, where parked and moving traffic both appear, and report the same metrics.
The third experiment covers short indoor dynamic scenes: TUM walking sequences, Bonn RGB-D Dynamic, and the WildGS-SLAM MoCap split, all run in monocular mode. The purpose is a no-harm check. Persistence weighting must not degrade the existing within-visit results.
The fourth experiment measures map quality after correction. We measure PSNR on held-out views of static regions at revisited places, and count duplicate surfaces by depth-histogram bimodality along rays. We compare against GLC-SLAM-style deformation that moves Gaussians with their keyframes but does not change their scale.
The decisive outcome combines two results: a clear scale-error gap that grows with scene change on synthetic revisits, and an ATE gain on 4Seasons revisits over the tuned robust-estimation bolt-on. Either one alone is suggestive. Both together establish that cross-visit persistence is a missing variable in monocular loop closure.
References
- WildGS-SLAM: Monocular Gaussian Splatting SLAM in Dynamic Environments
- De4D-SLAM: Gradient-Isolated Static-Dynamic Decoupling for Monocular SLAM in Dynamic Environments
- HI-SLAM: Monocular Real-Time Dense Mapping With Hybrid Implicit Fields
- Loop Closure From Two Views: Revisiting PGO for Scalable Trajectory Estimation Through Monocular Priors
- Synthetic vs. Real Training Data for Visual Navigation
- TartanAir: A Dataset to Push the Limits of Visual SLAM
- DGS-SLAM: Gaussian Splatting SLAM in Dynamic Environment
- VGGT-Motion: Motion-Aware Calibration-Free Monocular SLAM for Long-Range Consistency