PRISM-SLAM: Probabilistic Metric Monocular SLAM

• PRISM-SLAM is a monocular SLAM system that probabilistically integrates depth priors with Bayesian optimization to achieve scale-aware, metric mapping.
• It introduces a novel Plücker Ray-Distance Factor and uses Dynamic Scene Uncertainty Gating to overcome monocular scale ambiguity and dynamic scene challenges.
• The system operates in real time by decoupling high-rate geometric tracking from lower-frequency depth inference, achieving near-oracle metric accuracy.

Searching arXiv for the cited PRISM-SLAM paper and the earlier PRISM paper for citation support. I’m checking arXiv records relevant to PRISM-SLAM to ground the article in current preprints. PRISM-SLAM, short for Probabilistic Ray-Grounded Inference for Scale-aware Metric SLAM, is a monocular RGB-only SLAM system introduced to address two longstanding limitations of monocular geometry simultaneously: the lack of absolute metric scale and the fragility of visual SLAM in dynamic scenes. The method integrates vision foundation model depth priors into a structured Bayesian factor graph, rather than treating them as deterministic ground truth, and uses a new Plücker Ray-Distance Factor to anchor monocular observations in a globally consistent metric coordinate system. In the paper’s terminology, scale-aware metric SLAM means estimating trajectory and map directly in metric space at runtime, without oracle scale recovery or post-hoc rescaling; the central empirical claim is that the system’s metric $SE(3)$ Absolute Trajectory Error (ATE) is nearly identical to its oracle-aligned $Sim(3)$ error, indicating deployment-ready metric output from monocular RGB alone (Im, 19 May 2026).

1. Problem setting and conceptual scope

PRISM-SLAM is positioned against three limitations of prior monocular SLAM. First, standard monocular methods such as ORB-SLAM3 recover trajectories only up to an unknown global scale. Second, that scale can drift over time because the optimization objective contains no true metric anchor. Third, moving people and objects violate the rigidity assumptions underlying feature-based tracking and bundle adjustment, causing tracking failure in dynamic environments (Im, 19 May 2026).

The paper begins from the standard monocular reprojection objective

$$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$

where $T_i=(R_i,t_i)\in SE(3)$ denotes pose, $X_j$ a landmark, $p_{ij}$ an image observation, $K$ the camera intrinsics, $\pi(\cdot)$ the projection operator, $\Sigma_{ij}$ an information matrix, and $\rho$ a robust loss. The key invariance is

$Sim(3)$0

which expresses the classical scale ambiguity of monocular bundle adjustment. Because perspective division cancels common scale, the Hessian has a null direction in the scale dimension. The paper describes this as a rank-deficient null-space, implying that pure monocular reprojection provides no gradient signal that constrains global metric scale (Im, 19 May 2026).

Vision foundation model depth priors are introduced as an external cue to metric geometry. PRISM-SLAM uses DA3 as the depth prior, but emphasizes that deterministic integration is insufficient because the predictions are uncertain, heteroscedastic, and often inconsistent across frames in both scale and local geometry. The method therefore treats these outputs as uncertain priors in a Bayesian factor graph, weighted by uncertainty and filtered over time rather than inserted as exact metric supervision (Im, 19 May 2026).

2. System architecture and runtime organization

The system takes monocular RGB frames as input and outputs a metric camera trajectory, a sparse metric map during online operation, and optionally a dense point cloud from an offline reconstruction stage. Its architecture is explicitly asynchronous and multi-process. According to the paper and appendix, it consists of four processes: a CPU ORB-based tracking frontend running at about $Sim(3)$1 FPS; an asynchronous GPU worker running the DA3 depth foundation model on keyframes; a metric optimizer performing log-domain weighted least-squares scale estimation plus Kalman filtering; and an optional dense reconstruction process using DSUG-gated depth maps (Im, 19 May 2026).

This separation underpins the real-time claim. Foundation-model depth inference is lower-frequency and more expensive than geometric tracking, so PRISM-SLAM decouples high-rate geometry from slower metric-prior computation. The frontend performs sparse feature tracking, PnP-RANSAC, and local mapping in the style of classic monocular SLAM, while the backend enforces metric inference through factor-graph optimization. Loop detection uses the DA3 ViT $Sim(3)$2 token as a global descriptor, allowing the same foundation model to support both metric depth prediction and place recognition (Im, 19 May 2026).

Initialization is metric-aware and is the only synchronous stage. The first $Sim(3)$3 keyframes are processed synchronously to obtain a robust initial metric scale. A robust initial scale $Sim(3)$4 is computed via log-domain weighted least squares, then used to warm-start the Kalman filter and anchor the first map points metrically. If motion is degenerate, such as near-pure rotation with poor triangulation baseline, the synchronization window is extended until a stable baseline exists. This makes translational baseline an explicit practical assumption of the method (Im, 19 May 2026).

3. Probabilistic formulation and metric anchoring

PRISM-SLAM is described as a Bayesian factor graph whose optimized latent variables include camera poses $Sim(3)$5, 3D landmarks $Sim(3)$6, a global or temporally filtered scale variable $Sim(3)$7 represented in the log domain, per-pixel or per-observation depth and ray priors from the foundation model, and uncertainty-derived precision weights $Sim(3)$8. The backend jointly optimizes standard reprojection edges together with the proposed Plücker ray-distance and metric depth factors (Im, 19 May 2026).

The paper does not present one single posterior factorization over all variables, but it does describe the optimization as a weighted robust nonlinear least-squares objective composed of reprojection, ray-distance, metric-depth, scale, and loop-closure terms. A faithful summary of the backend objective is

$Sim(3)$9

The exact residuals $$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$0 and $$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$1 are not written explicitly in the provided text, so the paper-grounded description remains at the level of “metric depth factors” and log-domain scale filtering (Im, 19 May 2026).

The method’s main technical novelty is the Plücker Ray-Distance Factor. For a camera at pose $$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$2, with metric 3D direction vector $$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$3, the corresponding ray is represented in 6D Plücker coordinates as

$$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$4

The orthogonal distance from a world point $$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$5 to that ray is

$$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$6

This residual is zero exactly when $$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$7 lies on the infinite line defined by the ray. The paper’s core claim is that, unlike pure reprojection constraints, these ray-distance residuals are anchored in a globally metric coordinate frame by the VFM prediction. As a result, a global rescaling of the map forces landmarks to deviate from the anchored rays and increases the residual. The paper therefore argues that the metric scale becomes Fisher-identifiable because the scale null-space of monocular reprojection is removed (Im, 19 May 2026).

This identifiability claim is not presented as a full theorem with a closed-form Fisher information matrix. Rather, it is argued through residual sensitivity and null-space elimination: under pure reprojection the global scale direction is a null direction, whereas under the added ray-distance residual the derivative along scale is nonzero because anchored metric rays do not rescale with the map. The paper explicitly frames this as local Fisher identifiability rather than a stronger global observability result (Im, 19 May 2026).

4. Dynamic Scene Uncertainty Gating and log-domain scale filtering

To handle environmental dynamics, PRISM-SLAM introduces Dynamic Scene Uncertainty Gating (DSUG). The method’s motivation is that hard masks, especially those derived from semantic segmentation or learned dynamic classifiers, abruptly remove residuals from the graph and create gradient discontinuities that are harmful for nonlinear solvers such as Levenberg–Marquardt. DSUG instead applies soft probabilistic weighting (Im, 19 May 2026).

Because DA3 does not provide an explicit predictive-variance head, the paper constructs an epistemic uncertainty proxy $$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$8 by blending spatial and temporal terms: $$E = \sum_{i,j} \rho \left( \left\| p_{ij} - \pi(K (R_i X_j + t_i)) \right\|^2_{\Sigma_{ij}} \right),$$9 Here $T_i=(R_i,t_i)\in SE(3)$0 is obtained by inverting DA3’s native spatial confidence map, while $T_i=(R_i,t_i)\in SE(3)$1 is defined as the depth discrepancy between consecutive keyframes after compensating for camera ego-motion. The paper does not provide a fully expanded temporal warping equation, but it states that temporally inconsistent regions often coincide with moving people and unstable boundaries (Im, 19 May 2026).

The uncertainty proxy is converted into a smooth gate through

$T_i=(R_i,t_i)\in SE(3)$2

where $T_i=(R_i,t_i)\in SE(3)$3 is the normalized gating weight, $T_i=(R_i,t_i)\in SE(3)$4 is the uncertainty threshold, $T_i=(R_i,t_i)\in SE(3)$5 is a temperature controlling transition sharpness, $T_i=(R_i,t_i)\in SE(3)$6 is the nominal measurement-noise calibration, and $T_i=(R_i,t_i)\in SE(3)$7 is the resulting precision. Static and reliable pixels with low uncertainty obtain $T_i=(R_i,t_i)\in SE(3)$8, while dynamic or unreliable pixels receive a lower but nonzero weight. Thus DSUG weakens factors rather than deleting them. Appendix details specify $T_i=(R_i,t_i)\in SE(3)$9 and $X_j$0 (Im, 19 May 2026).

A separate asynchronous scale estimator complements DSUG. Since scale is a positive multiplicative quantity, PRISM-SLAM represents it in log space. A single-frame scale observation is computed via weighted least squares in the log domain, with DSUG-derived information matrices serving as WLS precision weights. These observations are then passed into a one-dimensional Kalman filter, using the WLS variance as adaptive measurement noise. The output scale estimate $X_j$1 is therefore strictly positive. The exact WLS algebra and Kalman state equations are not given in the provided text, but the paper’s model is explicit: noisy $X_j$2 observations, a filtered hidden state $X_j$3, adaptive measurement covariance from WLS uncertainty, and frontend/backend feedback through exponentiation (Im, 19 May 2026).

5. Optimization, loop closure, and dense reconstruction

The backend performs MAP inference via robust nonlinear least squares. During regular tracking it runs local windowed bundle adjustment, and after loop closure it runs global bundle adjustment. Appendix details specify a local bundle-adjustment window of $X_j$4 keyframes and 15 backend iterations. Huber robust kernels are used with thresholds

$X_j$5

The ray factor specifically uses a Huber robust kernel with $X_j$6 (Im, 19 May 2026).

Loop closure is implemented using the DA3 ViT $X_j$7 token as a $X_j$8-D global descriptor. Candidate loops are found by cosine similarity and verified by essential matrix estimation inside RANSAC. Upon acceptance, metric global bundle adjustment jointly optimizes reprojection, Plücker ray, and metric depth factors. The paper does not describe marginalization formulas or incremental smoothing techniques such as iSAM2; the inference structure is closer to standard local/window BA with global BA after loop closure (Im, 19 May 2026).

The DA3 prior serves three distinct roles: dense metric depth prediction, a spatial confidence map used in uncertainty estimation, and the ViT $X_j$9 token used for loop closure. Depth predictions are not inserted as hard constraints; they are converted into metric rays and depth factors, weighted by uncertainty. The paper emphasizes that frame-to-frame scale inconsistency in VFM predictions is handled both globally through log-domain WLS plus Kalman filtering and locally through DSUG weighting and robust optimization (Im, 19 May 2026).

PRISM-SLAM also includes an offline dense reconstruction stage. After the online metric trajectory is optimized, batches of keyframes and their optimized poses are fed into DA3’s native multi-view mode. This leverages cross-view attention to produce more consistent depths than independent single-view prediction. Dynamic regions are again filtered by DSUG before back-projection into a dense point cloud. The paper attributes the resulting geometric improvements to cross-view attention enforcing consistency at the feature level rather than after-the-fact geometric filtering (Im, 19 May 2026).

6. Empirical performance, ablations, and limitations

PRISM-SLAM is evaluated on TUM RGB-D, 7-Scenes, and BONN Dynamic using only monocular RGB input on an NVIDIA RTX 4500 Ada GPU; the appendix also includes a demonstration on KITTI Odometry. The central evaluation distinction is between $p_{ij}$0 ATE, which allows oracle alignment with a global scale correction, and $p_{ij}$1 ATE, which permits only rigid alignment and therefore tests metric scale recovery directly. The paper reports median results over 3 independent runs unless otherwise stated (Im, 19 May 2026).

On TUM fr1/xyz, PRISM-SLAM achieves

$p_{ij}$2

which the paper interprets as only a $p_{ij}$3 scale error. On TUM fr3 static sequences, reported results are $p_{ij}$4 cm on sit and $p_{ij}$5 cm on walk-static $p_{ij}$6. On dynamic fr3 sequences, the system remains functional with metric output but degrades to $p_{ij}$7 cm on sit-xyz and $p_{ij}$8 cm on walk-xyz (Im, 19 May 2026).

On BONN Dynamic, which is especially important for DSUG, PRISM-SLAM reports $p_{ij}$9 cm on balloon, $K$0 cm on balloon2, $K$1 cm on pers_trk, and $K$2 cm on balloon_trk. The paper notes that many comparison baselines use RGB-D hardware to obtain absolute scale, whereas PRISM-SLAM recovers metric scale monocularly. On 7-Scenes, with a learned frontend based on KeyNet, the method attains a mean $K$3 ATE of $K$4 cm across all scenes, with per-scene results including Chess $K$5 cm, Fire $K$6 cm, Heads $K$7 cm, Office $K$8 cm, Pumpkin $K$9 cm, Redkitchen $\pi(\cdot)$0 cm, and Stairs $\pi(\cdot)$1 cm. The large gap on Heads is one of the paper’s clearest failure cases and is explicitly associated with extreme rotational motion (Im, 19 May 2026).

Loop closure results support the use of the DA3 descriptor. On TUM fr1/xyz, ViT-driven loop closure reduces ATE RMSE from $\pi(\cdot)$2 cm to $\pi(\cdot)$3 cm, a $\pi(\cdot)$4 improvement, with 30 verified loops. On a 600-frame fr3/sit_static sequence, 31 loop closures were found with zero false positives, reducing ATE RMSE from $\pi(\cdot)$5 cm to $\pi(\cdot)$6 cm and increasing tracked frames from 401 to 480 (Im, 19 May 2026).

The ablation study on three standard sequences reports mean $\pi(\cdot)$7 ATE of $\pi(\cdot)$8 cm for the full system, compared with $\pi(\cdot)$9 cm without the Plücker Ray Factor, $\Sigma_{ij}$0 cm without DSUG, $\Sigma_{ij}$1 cm without the log-domain Kalman filter, and $\Sigma_{ij}$2 cm without WLS. The largest degradation occurs when the Plücker factor is removed, supporting the paper’s claim that it is the principal mechanism resolving scale ambiguity. DSUG has its strongest effect on BONN Dynamic, where the full system yields mean $\Sigma_{ij}$3 ATE of $\Sigma_{ij}$4 cm and the version without DSUG yields $\Sigma_{ij}$5 cm; on pers_trk, the error rises from $\Sigma_{ij}$6 cm to $\Sigma_{ij}$7 cm without DSUG (Im, 19 May 2026).

The reported runtime claim is verified metric output at $\Sigma_{ij}$8 FPS using RGB-only input. Appendix details specify a CPU C++ ORB tracker at approximately $\Sigma_{ij}$9 FPS, DA3-Large as an asynchronous GPU worker on keyframes, a Python metric optimizer with log-domain WLS and Kalman filtering, and an optional dense map backend. Additional implementation details include $\rho$0 ORB features on TUM, $\rho$1 KeyNet features on 7-Scenes, local BA window $\rho$2, 15 backend iterations, and the DSUG and Huber parameters noted above. When KeyNet is used for texture-poor 7-Scenes, throughput drops to about $\rho$3 FPS because of added GPU overhead (Im, 19 May 2026).

The paper’s stated strengths are real-time online operation, explicit metric output under strict $\rho$4 evaluation, uncertainty-aware integration of foundation-model priors, dynamic-scene robustness through DSUG, and loop closure at effectively no additional feature-extraction cost because the same model supplies the descriptor. Its stated weaknesses are dependence on the quality and consistency of DA3 depth predictions, degradation in highly dynamic scenes with severe occlusion, failure or temporary drift under extreme rotational motion where triangulation and scale cues are weak, residual moving-object contamination in dense reconstruction, and reduced throughput when stronger learned local features are used. The initialization procedure also assumes enough translational motion to establish a robust geometric baseline; pure rotation or weak parallax can delay initialization (Im, 19 May 2026).

7. Relation to the earlier PRISM acronym

PRISM-SLAM is distinct from the earlier system PRISM, “Probabilistic Real-Time Inference in Spatial World Models,” which is a real-time probabilistic dense RGB-D SLAM filter derived from a predefined state-space generative model of 6-DoF agent motion and RGB-D visual perception (Mirchev et al., 2022). The earlier PRISM maintains approximate posterior beliefs over both a voxelized dense map and the current agent state, and is formulated as filtering rather than smoothing; it is not a monocular scale-aware metric-SLAM method and does not address monocular scale ambiguity through metric ray anchoring (Mirchev et al., 2022).

The naming overlap can create a superficial association, but the two systems occupy different methodological positions. PRISM-SLAM is centered on monocular RGB input, probabilistic integration of VFM depth priors, the Plücker Ray-Distance Factor, DSUG, and explicit online metric-scale recovery (Im, 19 May 2026). By contrast, PRISM is a dense RGB-D probabilistic SLAM filter with a voxel-grid map, differentiable rendering assumptions, Gaussian map and state uncertainty, and a 6-DoF dynamics model, reported at 10–15 Hz on EuRoC, Blackbird, and TUM-RGBD (Mirchev et al., 2022). This suggests that the shared acronym should not be taken to imply a shared formulation beyond a broad probabilistic SLAM orientation.