Skip to content

Predictive Photometric Uncertainty in Gaussian Splatting for Novel View Synthesis

Conference: ECCV 2026
Paper: ECCV Virtual
Area: 3D Vision
Keywords: Gaussian Splatting, uncertainty estimation, novel view synthesis, linear least squares, active view selection

TL;DR

Uncertainty is turned into a spherical-harmonic channel on each 3D Gaussian that is isomorphic to color; it is fitted to training-view residual maps by solving a linear least-squares problem built from frozen alpha-blending weights and regularized with a Bayesian prior, yielding per-pixel uncertainty maps for arbitrary novel views — AUSE(DSSIM) on Mip-NeRF360 drops from 0.495 to 0.214 and Pearson correlation rises from 0.160 to 0.547 at only 12.8% extra training time.

Background & Motivation

Radiance fields are evolving from pure novel view synthesis engines into spatial maps for autonomous agents, yet inverting 2D images into a 3D scene is an ill-posed problem to begin with. In real deployments severe occlusions, unobserved regions and geometric ambiguities are unavoidable, so knowing where the render cannot be trusted becomes as important as how photorealistic it looks. 3D Gaussian Splatting has quickly become the leading representation thanks to differentiable rasterization over explicit primitives, and its fidelity, geometric consistency and efficiency have all been pushed hard — but equipping it with system-level uncertainty estimation (UE) remains an under-explored gap. Existing 3DGS UE work falls into two complementary families depending on whether it quantifies uncertainty in the learned representation (the Gaussian parameters) or in the rendered radiance field (the pixels).

The problem is that the first family dominates. Stochastic formulations (Stochastic-GS, Variational-3DGS, Manifold sampling, Continuous Semantic Splatting) place distributions over Gaussian parameters and derive pixel-level uncertainty from multi-sample variance; the price is sampling-based optimization with prohibitive latency, mandatory architectural and optimization changes, and degraded rendering fidelity, while remaining incompatible with the rapidly expanding ecosystem of 3DGS variants. Post-hoc alternatives instead estimate epistemic uncertainty in parameter space through Hessian approximations (FisherRF via Fisher information, POp-GS via P-optimal experimental design with inter-parameter correlations). These leave the architecture alone, but as this paper's experiments show, such parameter-centric methods capture view-dependent uncertainty poorly — FisherRF's predicted uncertainty is negatively correlated with the true error on all three datasets. Yet what downstream tasks actually consume are rendered pixels; they need to know whether this pixel is trustworthy, not how confident the model is about a set of Gaussian parameters.

This paper's angle comes from a simple but powerful observation: regions with large reconstruction residual on the training views are precisely the regions 3DGS failed to fit — both geometric under-reconstruction (fragmented vegetation, say) and limited view-dependent appearance capacity (reflections on a table). Rather than detouring through parameter space, the authors model uncertainty directly in the rendered radiance field and cast it as a linear least-squares problem: the only unknowns are per-primitive uncertainty values, the blending-weight matrix is built from frozen opacities and transmittances, so the objective is convex, solvable efficiently with SGD, and requires zero modification to the underlying representation. The one trap is that under sparse-view capture the heavily parameterized 3DGS overfits the training views and drives residuals toward zero, falsely declaring zero uncertainty; an L2 prior centered at maximal uncertainty pulls back the viewing directions that have no training evidence. Core idea: treat uncertainty as a third splattable primitive attribute, with training residuals as the regression target and a Bayesian-regularized linear least-squares solver, producing view-dependent, per-pixel, architecture-agnostic reliability maps.

Method

Overall Architecture

The input is an already trained 3DGS scene plus its training views (with SfM poses); the output is a per-pixel uncertainty map for any (novel) viewpoint — same resolution as the RGB image, rendered in the same way and at the same speed. The pipeline is strictly post-hoc: first compute per-pixel photometric residuals on the training views, then render each Gaussian's uncertainty feature as a "splattable channel" parallel to color, and finally optimize only these newly added parameters so that they explain those residuals. The positions, covariances, opacities and spherical-harmonic colors of the original model stay frozen throughout, so rendering fidelity is preserved exactly and the method can be attached to any 3DGS variant.

Concretely, there are three steps. First, render every training view from the frozen model and compute per-pixel residuals \(L_x\) using 3DGS's native photometric error \(L_x=(1-\lambda)L1_x+\lambda\,\mathrm{DSSIM}_x\) with \(\lambda=0.2\), producing residual maps. Second, give each Gaussian \(k\) an uncertainty feature \(u_k\) modeled with spherical harmonics (SH) to capture its dependence on viewing direction — for the same reason color needs SH: the same surface patch shows different error when seen from different angles. Rendering reuses the identical alpha-blending rule with "uncertainty" substituted for "color," so the pixel uncertainty from any viewpoint is the transmittance- and opacity-weighted sum of per-primitive uncertainties along the ray. Third, arrange all pixels of all training views into one linear system, back-propagate gradients only to \(u_k\) (and to their SH coefficients), solve with SGD, and add a Bayesian prior that pulls directions lacking training evidence toward maximal uncertainty.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Trained 3DGS + training views"] --> B["Per-pixel photometric residual maps<br/>L1 + DSSIM, base params frozen"]
    B --> C["Per-primitive uncertainty channel<br/>SH features isomorphic to color"]
    C --> D["Residual least squares<br/>weight matrix built across all views"]
    D --> E["Bayesian prior regularization<br/>no-evidence directions revert to max"]
    E --> F["Uncertainty rendered at any pose"]
    F --> G["Downstream: active view selection /<br/>change detection / anomaly detection"]

Key Designs

1. Per-primitive uncertainty channel: rendered with the exact rules used for color

The pain point is a mismatch between parameter-space UE and downstream needs. FisherRF and POp-GS report how confident the model is about its Gaussian parameters, while stochastic methods do produce pixel-level uncertainty but must change the Gaussian parameterization, pay a sampling cost and sacrifice fidelity — and still do not guarantee a view-dependent quantity. This paper instead defines uncertainty on the primitives and lets the rendering pipeline itself aggregate it into pixels: each Gaussian carries an extra scalar function \(u_k(d)\) defined by SH coefficients, and the contribution of primitive \(k\) to pixel \(x\) is its uncertainty multiplied by the opacity and transmittance at that pixel, summed along the ray:

\[U(x)=\sum_{k=1}^{K}u_k(d)\,\alpha_k(x)\,T_k(x)\]

Note this differs from the 3DGS color equation in exactly one place: the view-dependent color \(c_k(d)\) is replaced by the view-dependent uncertainty \(u_k(d)\). This isomorphism brings three immediate benefits. First, uncertainty is view-dependent for free — changing the viewing direction changes each primitive's \(u_k(d)\) and also changes which primitives are occluded and what the transmittances are, with no auxiliary inference network. Second, the rendering overhead is zero: it is one more pass of the existing rasterizer, so producing a map at an arbitrary new pose costs the same as producing the RGB image. Third, because all base parameters are frozen, the only added parameters are \((D+1)^2\) scalars per Gaussian (16 at SH degree 3), training memory is actually below vanilla 3DGS, and rendering fidelity is preserved exactly — something stochastic methods cannot claim, and the precondition for the method to be plug-and-play across 3DGS variants.

2. Residual least squares: one linear system over all training pixels, disentangling the "collective blame" of overlapping Gaussians

This second ingredient targets a more naive family of approaches. PUP 3D-GS and Speedy-Splat compute pruning scores from L2 loss sensitivity, and Rota Bulò et al. derive a densification score directly from rendering error. They share the intuition of scoring primitives by reconstruction error, but the scoring is per-pixel: when an artifact appears at one pixel, every Gaussian overlapping that pixel receives an elevated score even though a single one is responsible. This collective blame is harmless for densification (over-densification is corrected by subsequent optimization) but falsely penalizes reliable primitives in a frozen model.

The fix is to place all pixels of all training views into a single linear system. Since \(U\) is linear in \(u\), writing the blending weight of primitive \(k\) at pixel \(j\) as \(A_{jk}=\alpha_k(x_j)\hat T_k(x_j)\) (with \(\hat T_k\) the transmittance after depth-sorting along that pixel's ray) makes the rendered uncertainty a matrix-vector product \(Au\), while the regression target \(y_j\) is that pixel's reconstruction residual. Estimating per-primitive uncertainty is then equivalent to

\[\arg\min_{u}\ \|Au-y\|_2^2\]

Solving for all pixels simultaneously is where the value lies: the same residual is spread across primitives in proportion to their weights at that pixel, so a reliable primitive that happens to overlap an artifact is not pushed up wholesale the way per-pixel heuristics would push it. This is exactly what the paper calls disentangling the interactions between overlapping Gaussians. View dependence does not break linearity either: the SH basis functions are simply absorbed into \(A\) and \(u\) expands from one scalar per primitive to the concatenation of 16 SH coefficients per primitive (degree 3), while \(A\) still depends only on the frozen \(\alpha\) and \(T\).

The solver deserves emphasis. With millions of primitives times 16 coefficients, the normal equations \(A^\top A u=A^\top y\) are far too large for a direct solver even though the matrix is sparse. The authors fall back on the same SGD procedure used for the other Gaussian parameters, noting that the least-squares objective is convex and therefore converges efficiently and stably. Convexity here is not decoration: it is the technical basis that makes trading "sampling overhead of stochastic methods" for "one convex optimization" a sound bargain.

3. Bayesian prior regularization: directions without training evidence revert to maximal uncertainty

Least squares only learns from viewing directions present in the training data, which causes trouble under sparse capture — and the trouble is twofold. On one hand, SH-modeled directional functions receive no supervisory signal over the spherical regions not covered by training views. On the other, and more insidiously, with only four training views the extremely high parameterization of 3DGS is enough to drive training residuals close to zero, so the residual map signals "no error here, uncertainty is zero" — a signal that is simply wrong at genuinely novel viewpoints. The problem being solved is over-confidence, not under-fitting.

The remedy is an L2 prior on the directional uncertainty function, penalizing deviation from a constant \(b\):

\[\ell_k=\int_{\mathbb{S}^2}\bigl(b-u_k(r)\bigr)^2\mathrm{d}r,\qquad \mathcal{L}_{\mathrm{reg}}=\sum_{k=1}^{K}\ell_k\]

The spherical integral is approximated by Gauss-Legendre sampling, and the final objective is \(\mathcal{L}'=\mathcal{L}+\lambda_{\mathrm{reg}}\mathcal{L}_{\mathrm{reg}}\). The justification is the standard equivalence between L2-regularized linear regression and Bayesian inference under a Gaussian prior, so adding it does not mean "guess \(b\) where there is no evidence" but rather "pull the posterior back to the prior along unsupported directions." The value of \(b\) is not arbitrary either: since \(u\) regresses the photometric residual whose magnitude is bounded by the normalized intensity range, the maximum residual is 1, making \(b=1\) correspond to maximal, isotropic uncertainty — a principled choice. Viewed another way, the regularizer is suppressed by the data term along well-covered directions and only takes effect where evidence is missing, which explains why \(\lambda_{\mathrm{reg}}=0\) suffices for dense capture (Sec. 4.1) while sparse settings make it essential.

Loss & Training

The training objective is the L2 difference between residuals and rendered uncertainty, with gradients back-propagated only to the uncertainty channels (the weight matrix \(A\) is fixed, preserving linearity):

\[\mathcal{L}=\sum_x\bigl(L_x-U_x\bigr)^2,\qquad \mathcal{L}'=\mathcal{L}+\lambda_{\mathrm{reg}}\mathcal{L}_{\mathrm{reg}}\]

where \(L_x=(1-\lambda)L1_x+\lambda\,\mathrm{DSSIM}_x\) with \(\lambda=0.2\) inherited directly from 3DGS. Key settings:

  • Dense setting (standard protocol on Mip-NeRF360 / Tanks & Temples / Deep Blending) uses \(\lambda_{\mathrm{reg}}=0\) — the paper states explicitly that the Bayesian regularization yields only marginal gains under dense capture and is designed for sparse-view regimes.
  • Highly novel view setting uses only 4 training views (chosen by maximizing pairwise camera-center distances); the base model is trained for 4,000 iterations and the uncertainty channel for 400. Here \(b=1\), background regions are assigned uncertainty 1, and no explicit background prior is imposed when regularization is disabled.
  • Active view selection (AVS): starting from 4 initial views, between selections the base 3DGS is trained for \(100\times N_{\text{views}}\) iterations (\(N_{\text{views}}\) the current training-view count) and the uncertainty channel for \(50\times N_{\text{views}}\) iterations; the candidate with the highest total uncertainty is selected, 16 in total, for 20 training views overall.
  • Overhead: roughly 12.8%–14.0% of vanilla 3DGS training time; \((D+1)^2\) extra scalars per Gaussian, with freezing keeping training memory below standard 3DGS.

Key Experimental Results

The evaluation protocol follows 3DGS exactly: uncertainty estimation is assessed on Mip-NeRF360, Tanks & Temples and Deep Blending using AUSE (area under the sparsification error curve; lower means the uncertainty ranks true errors better) and Pearson correlation between predicted uncertainty and per-pixel true error (higher is better), each computed against both L1 and DSSIM error maps. DSSIM matters particularly here: NVS errors mostly stem from structural distortion such as geometric misalignment, blur or floaters rather than plain intensity shifts, so the perceptual DSSIM is a more meaningful measure of "where the render really broke" than L1.

Main Results

Table 1: Uncertainty estimation for NVS (hold-out views; OH is extra training time as a percentage of vanilla 3DGS).

Dataset Method AUSE(L1)↓ AUSE(DSSIM)↓ Pearson(L1)↑ Pearson(DSSIM)↑ OH↓
Mip-NeRF360 FisherRF 0.708 0.606 −0.055 0.009 14.2%
Mip-NeRF360 Manifold 0.520 0.559 0.070 −0.005 30.2%
Mip-NeRF360 Var3DGS 0.558 0.495 0.118 0.160 >100%
Mip-NeRF360 Ours 0.328 0.214 0.369 0.547 12.8%
Tanks & Temples FisherRF 0.691 0.709 −0.087 −0.145 19.3%
Tanks & Temples Manifold 0.574 0.654 0.053 0.008 23.6%
Tanks & Temples Var3DGS 0.539 0.567 0.161 0.176 >100%
Tanks & Temples Ours 0.299 0.233 0.427 0.571 14.0%
Deep Blending FisherRF 0.751 0.853 −0.116 −0.190 19.7%
Deep Blending Manifold 0.503 0.548 0.095 0.074 48.1%
Deep Blending Var3DGS 0.588 0.671 0.106 0.006 >100%
Deep Blending Ours 0.376 0.356 0.243 0.244 13.0%

Table 2: Downstream task — active view selection (Mip-NeRF360, hold-out metrics after 20 training views).

Method PSNR↑ SSIM↑ LPIPS↓
FisherRF 20.266 0.593 0.363
Manifold 19.732 0.595 0.373
Manifold† (its view predictions driving vanilla 3DGS) 20.088 0.611 0.350
Ours 20.676 0.615 0.344

Note: AVS is evaluated at full resolution to strictly follow the 3DGS protocol, which is why the PSNR values here (~20) are lower than numbers reported by some prior work that does not evaluate at full resolution — a protocol difference, not a regression of the method. Manifold† is introduced purely for fairness: Manifold's variational optimization slightly degrades the fidelity of the underlying 3DGS, so comparing against its view predictions directly would be unfair.

Table 3: Downstream task — pose-agnostic scene change detection (PASLCD benchmark; ∆ is the percentage gain over that baseline itself).

Metric Feature Diff. +Ours ∆ MV3DCD-ZS +Ours ∆ MV3DCD +Ours ∆ Online-SCD +Ours ∆
mIoU↑ 0.278 0.359 +29.1% 0.382 0.439 +14.9% 0.470 0.498 +6.0% 0.486 0.498 +2.5%
F1↑ 0.402 0.502 +24.9% 0.526 0.593 +12.7% 0.621 0.649 +4.5% 0.638 0.651 +2.1%

Table 4: Downstream task — pose-agnostic anomaly detection (MAD-Real benchmark).

Metric SplatPose +Ours ∆ SplatPosePlus +Ours ∆
AUROC↑ 0.929 0.939 +1.1% 0.940 0.956 +0.7%
AUPRO↑ 0.700 0.765 +9.3% 0.761 0.798 +4.9%

Ablation Study

Table 5: Capacity ablation on view dependence (Mip-NeRF360, varying the SH degree used to model \(u_k\)).

Config AUSE(L1)↓ AUSE(DSSIM)↓ Pearson(L1)↑ Pearson(DSSIM)↑
No view dependence (SH degree 0) 0.391 0.310 0.217 0.356
SH degree = 1 0.352 0.245 0.327 0.498
SH degree = 2 0.331 0.218 0.353 0.535
SH degree = 3 (full) 0.328 0.214 0.369 0.547

Table 6: Sensitivity to the Bayesian regularization weight on highly novel views (4 training views; only the conclusive ranges the paper states are restated).

\(\lambda_{\mathrm{reg}}\) Observation / conclusion
0 (no regularization) DSSIM AUSE = 0.275, the worst of the qualitatively compared settings
0.32 DSSIM AUSE = 0.232
10.24 DSSIM AUSE = 0.215, the optimum for DSSIM, with marginal changes beyond
0.16 – 0.32 Optimal range under the L1 error

⚠️ Apart from the three DSSIM AUSE values (0 / 0.32 / 10.24) that Fig. 6 states explicitly, the \(\lambda_{\mathrm{reg}}\) sweep is given as curves (values 0, 0.02, 0.08, 0.32, 1.28, 5.12, 20.48, doubling from 0.02 onward); refer to Fig. 5b of the original paper for the full numbers. The method beats FisherRF at every \(\lambda_{\mathrm{reg}}\) value.

Key Findings

  • Parameter-space UE can be anti-correlated with true error. The most striking column in Table 1 is FisherRF's Pearson: negative on all three datasets (−0.055 to −0.190), meaning the regions it flags as highly uncertain are systematically misaligned with genuinely high-error regions. This work reaches 0.547 DSSIM correlation at its operating point, more than 3× the strongest baseline (Var3DGS). Empirically this backs the paper's central claim: for downstream tasks that consume pixels, modeling uncertainty in rendering space rather than parameter space is a necessity.
  • View dependence is not optional — it is a capacity question. Table 5 shows that lowering the SH degree from 3 to 0 drops Pearson(DSSIM) from 0.547 to 0.356 (−35%) and raises AUSE(DSSIM) from 0.214 to 0.310 (+45%). The degradation is monotone, confirming that uncertainty genuinely varies with viewing direction; treating it as a static per-primitive scalar visibly costs accuracy.
  • The optimal regularization strength depends on which error you care about. On highly novel views the optimal range for L1 is \(0.16\le\lambda_{\mathrm{reg}}\le0.32\), while DSSIM peaks at 10.24 — a gap of one and a half orders of magnitude. The authors also note these ranges are largely scene-independent (per-scene AUSE plots in App. C), so per-scene tuning is unnecessary — but one must still know which error metric the downstream task uses.
  • Gains are inversely related to baseline strength. In Table 3 the weaker the baseline, the larger the gain (Feature Diff. mIoU +29.1%), and the stronger the baseline the smaller the gain but still positive (Online-SCD +2.5%). This supports the reading that the uncertainty map suppresses render artifacts as a shared error source: the better a baseline already handles artifacts, the less room there is for uncertainty to help. Table 4 shows the same structure, and the guidance lets the older SplatPose match or surpass its successor SplatPosePlus, indicating the benefit comes from the reliability signal itself rather than a particular architecture.
  • Overhead is close to negligible. 12.8%–14.0% extra training time against Var3DGS's >100%, plus only 16 scalars per Gaussian, leaves almost no deployment friction for the use case of "adding a trustworthiness layer to an existing 3DGS."

Highlights & Insights

  • Turning uncertainty estimation from "train a regressor / sample an ensemble" into "solve a convex problem." PRIMU also does image-space UE but relies on hand-crafted features and a regressor trained on hold-out views; this work learns per-primitive, view-dependent uncertainty directly with linear least squares — no regressor, no hold-out views — while retaining the view dependence of stochastic methods. Any representation with explicit primitives and alpha blending (2DGS, dynamic 4D Gaussians, semantic Gaussians) can add such a channel as-is.
  • Freezing the base parameters is what makes fidelity and solvability hold at the same time. Because \(A\) is built only from frozen \(\alpha\) and \(T\), it is constant, so the problem is linear and convex, SGD reaches the global optimum, and not a single pixel of the original render changes. It is a clean trade that converts the constraint "must be post-hoc" into an advantage — instead of folding UE into the training loop, it buys plug-and-play.
  • The Bayesian prior addresses "unsupervised directions," not "unobserved regions." Once SH models directional dependence, spherical directions uncovered by training views simply have no gradient; a single L2 prior centered at maximal uncertainty supplies what is missing, treating those directions as "unknown" rather than "fine." The idea transfers to anything modeled with SH while supervised only on part of the sphere (directional radiance, view-dependent materials, illumination).
  • The real difference between per-pixel heuristic scoring and joint least squares is whether collective blame is disentangled. Primitive scoring in PUP 3D-GS, Speedy-Splat or Rota Bulò et al. is harmless in densification pipelines because mis-attributions get corrected by later optimization; but whenever the model is frozen and the scores drive decisions directly (pruning, edit localization, reliability masking), joint solving becomes necessary. That criterion transfers directly.

Limitations & Future Work

  • Two limitations the authors acknowledge. First, the strictly post-hoc nature bottlenecks the spatial granularity of the uncertainty maps by the density and scale of the underlying Gaussians — coarsely reconstructed regions (few large primitives) yield equally coarse uncertainty — and the authors deliberately do not add or remove primitives in order to preserve fidelity and structure. Second, the method estimates a single predictive uncertainty, conflating aleatoric, epistemic and optimization-related effects without producing a probabilistic distribution; the authors note this is not unique to them, since existing approaches also lack disentanglement and only stochastic formulations provide a probabilistic form.
  • Limitations I noticed. The residual metric itself was not ablated: the target \(L_x\) inherits 3DGS's L1 + 0.2·DSSIM, and what changes if one switches to LPIPS or normal/depth consistency is not discussed, even though the residual choice directly determines what \(u\) learns. Also, AUSE and Pearson are evaluated on hold-out views, whereas the genuinely hard cases for downstream SCD and AD are views whose poses deviate strongly from the training distribution — the two are not fully aligned, which may partly explain the smaller gains on the strongest baselines in Table 3.
  • Improvement directions. Making \(\lambda_{\mathrm{reg}}\) direction-adaptive — stronger prior along sparsely covered spherical directions, data-dominated elsewhere — could plausibly satisfy the L1 and DSSIM optima at once instead of forcing a choice between them. For the first limitation, allowing extra auxiliary primitives that carry uncertainty but do not participate in color rendering (or letting uncertainty be interpolated at multiple scales) would raise the spatial resolution of the uncertainty map without touching the RGB render.
  • vs FisherRF / POp-GS: Both are post-hoc and leave the architecture untouched. The difference is that they estimate epistemic uncertainty in parameter space (Fisher information, P-optimal experimental design) whereas this work estimates trustworthiness in rendered pixel space; in the experiments FisherRF's Pearson correlation with true error is negative while this work's is positive and large. The cost is that this work exposes no parameter-space quantity, so it cannot directly drive decisions like "which Gaussians to prune" based on parameter confidence.
  • vs Stochastic-GS / Variational-3DGS / Manifold sampling: They learn distributions over Gaussian parameters and derive pixel uncertainty from multi-sample variance; the upside is view dependence and a probabilistic form, the downside is architectural and optimization changes, heavy sampling cost (Var3DGS >100% overhead, Manifold 48.1% on Deep Blending) and slightly reduced rendering fidelity — which is exactly why the paper has to introduce Manifold† to make the AVS comparison fair.
  • vs PRIMU: Also image-space UE. The difference is that this work learns per-primitive, view-dependent uncertainty directly via linear least squares, whereas PRIMU relies on hand-crafted features and a regressor trained on hold-out views.
  • vs PUP 3D-GS / Speedy-Splat / Rota Bulò et al.: They share the intuition of scoring primitives by reconstruction error, but score per pixel to serve pruning and densification, so an artifact penalizes every overlapping primitive; this work solves jointly across all views to undo that collective blame.
  • vs Bayes' Rays: It interprets uncertainty as allowable volumetric variation in NeRF — an elegant design, but tightly coupled to neural volumetric representations and not directly applicable to 3DGS's explicit, non-neural parameterization.

Rating

  • Novelty: ⭐⭐⭐⭐ The core insight that residuals are a usable proxy is not new, but the combination — uncertainty as a third splattable attribute, a linear least-squares system built from frozen weights, and a Bayesian prior covering evidence-free directions — is new, and it moves UE from "modify training" all the way to "post-processing."
  • Experimental Thoroughness: ⭐⭐⭐⭐⭐ Three UE benchmarks × two error metrics × four baselines, plus three downstream tasks (active view selection, pose-agnostic scene change detection, pose-agnostic anomaly detection), two ablations (SH degree, regularization weight) and a plug-and-play check across 3DGS variants.
  • Writing Quality: ⭐⭐⭐⭐ The boundary against both prior families is drawn sharply and the argument for "rendering space over parameter space" is compelling; the deduction is for equation typesetting — several key formulas (e.g. the objective in Eq. 5) are corrupted in the preprint.
  • Value: ⭐⭐⭐⭐ Post-hoc, low-overhead, architecture-agnostic and fidelity-preserving — practical infrastructure for the "3DGS as a robotic spatial map" route, and the gains on three downstream tasks show it is more than a prettier metric.