Skip to content

GaussianLens: Localized High-Resolution Reconstruction via On-Demand Gaussian Densification

Conference: ECCV2026
Paper: ECCV 2026
Area: 3D Vision
Keywords: Gaussian Splatting, generalizable 3D reconstruction, on-demand Gaussian densification, localized high-resolution reconstruction, projection-based cross-attention

TL;DR

GaussianLens takes a low-resolution 3DGS reconstruction as a coarse scaffold, and for a region of interest (RoI) selected by the user with a 2D mask it takes sparse high-resolution images of that region as an extra input; a cross-modal network then predicts residual updates for the Gaussians inside the RoI and additionally sprouts one "pixel-guided Gaussian" per high-resolution pixel, turning localized high-fidelity reconstruction from "raise the global resolution" into one on-demand forward pass — 28.54 / 23.74 dB PSNR on RE10K 256→512 and DL3DV 256→1024, over 1 dB above comparable baselines, with 40% of the Gaussians a uniformly high-resolution model needs.

Background & Motivation

Generalizable 3D Gaussian prediction has made sparse-view reconstruction fast and stable over the past few years: pixelSplat, MVSplat and DepthSplat predict Gaussians for a whole scene in a single forward pass from a handful of images. Their Gaussians, however, are structured — typically pixel-aligned or voxel-aligned — and while that structure makes learning easy, it forces a uniform resolution: every pixel or voxel receives the same number of Gaussians, so seeing finer detail requires raising the reconstruction resolution globally, and compute and memory blow up accordingly. Two numbers from the paper make this vivid: DL3DV contains 3840×2160 videos, yet existing novel-view-synthesis work uses at most 960×540 and often defaults to 256×256; training DepthSplat on 1024×1024 inputs does not even fit on an 80GB H100. The other route is per-scene optimization. Vanilla 3DGS uses Adaptive Density Control to heuristically densify Gaussians in under-reconstructed regions, which naturally yields spatially non-uniform detail, but it needs dense observations and lengthy offline optimization and is therefore unusable in fast, interactive settings.

Uniformly high-resolution reconstruction of an entire scene is, moreover, usually wasteful. Human perception is actively focused: during an interactive room capture a user may only want to check whether the titles on book spines are legible, and care little about how many small dents the floor has. This produces a mismatch — on one side the prohibitive cost and large redundancy of global high-resolution reconstruction, on the other the user's genuine need for detail in a few local regions. A sensible design would give the reconstruction spatially varying degrees of detail, spending more Gaussians on critical regions, and would preferably produce those details on demand as the user's focus shifts rather than computing high resolution everywhere at once.

This paper therefore introduces a new problem setting: given a global 3DGS already reconstructed by a feed-forward model from low-resolution images, plus a region of interest (RoI) that the user selects with a 2D mask in the current view and a sparse set of high-resolution images of that region, the goal is to learn a generalizable network that densifies the Gaussians inside the RoI and recovers the details, with evaluation restricted to the RoI mask in high-resolution novel views. Core idea: cast the heuristic "densify-by-clone + subsequent optimization" of per-scene 3DGS as a one-step feed-forward cross-modal prediction — the network directly regresses where each Gaussian parameter should drift, while high-resolution pixels are back-projected into "pixel-guided Gaussians" that are seeded into the scene beforehand, so the network has primitives that can actually carry the detail.

Method

Overall Architecture

The input has two parts: an initial Gaussian reconstruction obtained by running a feed-forward 3DGS model (the paper uses DepthSplat) on low-resolution global captures, and high-resolution images together with the 2D binary masks of the user-selected RoI in each input view. The method first unions the initial Gaussians inside the mask (\(\mathcal{G}_{\text{RoI}}\)) with a set of "pixel-guided Gaussians" (\(\mathcal{G}_{\text{pixel}}\)) as the dense set to be densified, builds multi-modal features for them that fuse Gaussian parameters, rendering gradients, rendering residuals and multi-view image features, encodes these with a PTv3-based encoder (with projection-based cross-attention to images inserted inside), and finally has an MLP decoder output residual Gaussian parameters. The updated Gaussians are merged with the background Gaussians outside the RoI, i.e. \(\mathcal{G}_{\text{final}} = \mathcal{G}_{\text{den}} \cup \mathcal{G}_{\text{bg}}\), yielding a reconstruction that keeps global structure while carrying high-resolution detail locally. The whole pipeline runs in a single forward pass, with no per-scene optimization of any kind.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Low-res images<br/>+ known cameras"] --> B["Initial 3DGS reconstruction"]
    C["High-res RoI images<br/>+ 2D masks"] --> D["Pixel-guided densification"]
    B --> D
    D --> E["Multi-modal residual features<br/>params + grad + residual + proj."]
    E --> F["Projection-based multi-scale<br/>cross-attention"]
    F --> G["Residual densification decoder<br/>drift-style Gaussian params"]
    G --> H["Merge with background<br/>localized high-res recon."]

Key Designs

1. Pixel-guided densification: turn high-resolution pixels directly into carriers of detail

GaussianLens is conceptually a learned version of "clone + refine", but as the zoom factor grows, cloning existing Gaussians is far from enough: at 4× zoom-in a single initial Gaussian becomes solely responsible for a 4×4-pixel region, and aggregating that much information onto it and mapping it back to Gaussian parameters is a hard learning task. The ablation confirms this — when only the input Gaussians inside the RoI are densified (input, K×), raising the densification factor \(K\) from 4 to 16 actually moves PSNR from 23.27 slightly down to 23.25, so the bottleneck is not "how many clones" but "cloning what".

The paper therefore injects high-resolution evidence into the scene directly: for every pixel \(p_{i,xy}\) that falls inside the RoI mask \(M_i\) of view \(i\), a new Gaussian \(G_{i,xy}\) is spawned. Its color is initialized to the corresponding pixel color \(I_{i,xy}\); its 3D position is obtained by back-projecting the pixel along its camera ray onto the depth rendered from the coarse reconstruction; opacity and scale are initialized to small constants. The set to be densified then becomes \(\mathcal{G}_{\text{init}} \leftarrow \mathcal{G}_{\text{RoI}} \cup \mathcal{G}_{\text{pixel}}\), and both are fed to the network together. The point is that dense appearance becomes directly optimizable primitives: the network no longer has to squeeze detail out of a few coarse Gaussians, it only has to refine and select. The cost is a rise in Gaussian count (131K → 214K/220K), still far cheaper than the 524K of a globally high-resolution model; the paper also mentions an optional existence mask for selective densification (Supp. Sec. A.3).

2. Multi-modal residual feature initialization: let every Gaussian know where its rendering is wrong

Since the network predicts how Gaussian parameters should change, the features must simultaneously express "what is wrong right now" and "which image evidence can correct it". Each Gaussian's initial feature is a concatenation of three parts: the Gaussian parameters themselves (position, scale, rotation, opacity, color); the gradient of the rendering loss with respect to the parameters, \(\nabla_{G_j} L\), which attaches the residual signal directly to the Gaussian, following the idea of G3R; and the image features bilinearly interpolated at the projection of the Gaussian center into each view, which establishes 3D-to-2D correspondences. The image side is likewise a concatenation of three things: the raw image \(I_i\), dense multi-view features \(H^{\text{mv}}_i\) from a pretrained multi-view feature extractor, and — most importantly — reconstruction-residual features: the initial Gaussians are first rendered at the input views to produce RGB, depth and opacities \((\hat{I}_i, \hat{D}_i, \hat{A}_i)\), these are compared pixel-wise against the ground-truth images to give \(E_i = I_i - \hat{I}_i\), and the rendering outputs and the residual are packed into \(H^{\text{recon}}_i = (\hat{I}_i, \hat{D}_i, \hat{A}_i, E_i)\).

The design choice here is explicit association rather than leaving the network to guess: rendering the Gaussians, comparing against the images, and feeding the difference back amounts to handing the network a well-annotated spatial error map. This is also the most load-bearing feature in the ablation — removing \(H^{\text{recon}}\) drops the PSNR gain from +1.43 to +1.00, the largest loss among the three feature families; removing the gradient feature and the multi-view feature drops it to +1.27 and +1.22 respectively.

3. Projection-based multi-scale cross-attention: feed local image evidence to Gaussians where it is needed

The most obvious way to inject 2D image information into Gaussian features is global cross-attention, but its cost is quadratic in the number of Gaussians times image tokens, forcing it down to the bottleneck block on downsampled tokens — which throws away exactly the high-frequency detail this method wants to preserve. The paper instead uses projection-based cross-attention (ProjCrossAttn): the center \(p_j\) of Gaussian \(G_j\) is projected into each view \(i\), the image feature is bilinearly interpolated at that point to give \(h_{i,j} = H_i[\pi_{P_i}(p_j)]\), and a standard cross-attention is then applied with the Gaussian feature \(f_j\) as query and \(\{h_{i,j}\}_{i=1}^{N}\) as keys and values:

\[\texttt{ProjCrossAttn}\big((p_j, f_j), \{H_i, \mathbf{P}_i\}_{i=1}^{N}\big) = \texttt{CrossAttn}\big(\{f_j\}, \{h_{i,j}\}_{i=1}^{N}\big)\]

Its advantage is that it only establishes local correspondences — each Gaussian only reads the pixels it projects onto — so the cost grows linearly with the number of Gaussians and the layer can be run at high, undownsampled resolution. To cover multiple scales, the method builds a three-level image feature pyramid \((H, H^{\frac{1}{2}}, H^{\frac{1}{4}})\) and pairs low-resolution image features with downsampled, low-resolution Gaussians and high-resolution image features with full-resolution Gaussians, applying it in the last three decoder blocks of PTv3. The ablation is telling: no cross-attention at all gives only +0.34, and global cross-attention is even worse at +0.33 — the bottleneck-level global attention loses resolution and costs more; single-scale projection-based attention already reaches +1.28, and multi-scale pushes it to +1.43.

4. Residual densification decoder: distil "clone + refine" into a single forward pass

From the final features, an MLP decoder \(\phi_{\text{dec}}\) maps each initial Gaussian \(G_j\) to \(K\) new Gaussians, all expressed as residuals relative to the original Gaussian parameters — drifts in position, opacity, covariance and color:

\[\hat{G}^k_j = G_j + \Delta\hat{G}^k_j, \quad \{\Delta\hat{G}^k_j\}_{k=1}^{K} = \{(\Delta\mu^k_j, \Delta\alpha^k_j, \Delta\Sigma^k_j, \Delta c^k_j)\}_{k=1}^{K} = \phi_{\text{dec}}(f_j)\]

Predicting residuals instead of absolute parameters means the network only has to produce corrections, which keeps the output scale well behaved and matches the semantics of "continue optimizing an existing reconstruction". In the full model a densification factor of \(K=1\) suffices: the shortfall in quantity has already been covered by pixel-guided Gaussians, so the decoder only has to refine. The whole framework can thus be read as a learnable version of the "densify-by-clone + subsequent optimization" step in per-scene 3DGS — cloning is delegated to pixel-guided densification, optimization to residual prediction.

A Worked Example

Take the DL3DV 256→1024 (4×) setting and walk through it. The input is a set of 256×256 low-resolution global views, from which DepthSplat predicts about 131K Gaussians as the initial reconstruction. The user draws a small region in one frame (say the muntins of a window); this 2D selection is back-projected into 3D to give the RoI mask and the Gaussians belonging to the RoI, \(\mathcal{G}_{\text{RoI}}\), with the rest kept as background. The same views also exist at 1024×1024, but only a 256×256 crop enclosing the RoI is used. For every high-resolution pixel inside the mask, the method follows its camera ray to the 3D point where it hits the depth rendered from the coarse reconstruction, and places a new Gaussian there with the pixel's color and small constant opacity and scale — this is \(\mathcal{G}_{\text{pixel}}\). \(\mathcal{G}_{\text{RoI}} \cup \mathcal{G}_{\text{pixel}}\) then enters GaussianLens: multi-modal features are assembled per Gaussian (parameters, rendering gradients, projected image features from each view; on the image side the raw images, multi-view features and rendering residuals), the PTv3 encoder applies projection-based cross-attention over the three-level pyramid, and the decoder outputs a parameter drift per Gaussian. The updated Gaussians are merged with the background for a final count of roughly 220K (only about 89K more than the initial 131K), rendered at 4× the resolution, and the PSNR inside the RoI mask rises from 22.31 to 23.74. By contrast, DepthSplat high-res full, which tries to do the same thing directly at full 1024×1024 size, cannot even start training (out of memory on an 80GB H100).

Loss & Training

There is exactly one supervision signal: images rendered from the predicted Gaussians must match the ground truth at \(N'\) novel target views, counting only pixels inside the RoI masks and normalizing by the number of masked pixels:

\[L_{\text{MSE}} = \sum_{i=1}^{N'} \text{sum}\big(M_i \cdot \lVert I^i_{\text{pred}} - I^i_{\text{GT}} \rVert_2^2\big) \Big/ \sum_{i=1}^{N'} \text{sum}(M_i)\]

In other words, reconstruction outside the mask is not supervised at all: the model is explicitly trained to produce detail only in the region it is pointed at. On hyper-parameters, the main text gives only the 43M trainable parameters and the densification factor \(K=1\) for the full model; the remaining training details (network configuration, optimizer, the exact source of the multi-view feature extractor) are declared to be in Supp. Sec. B.1, and this note does not guess at them. Efficiency is measured on an NVIDIA A6000 with batch size 1: 1.74s per step and 13.27G of memory on the RE10K setting, 1.67s and 9.46G on the DL3DV setting. Note that training uses only Gaussians predicted by DepthSplat low-res full; because the input consists of Gaussian parameters alone and never touches the source model's internal features, the model transfers zero-shot to Gaussians from other sources (see the table below).

Key Experimental Results

Main Results

The paper builds an RoI novel-view-synthesis benchmark on RealEstate10K (RE10K) and DL3DV: low-resolution inputs are uniformly 256×256 full-size images, while the RoI's high-resolution images are 512×512 on RE10K and 1024×1024 on DL3DV, of which only the 256×256 crop enclosing the RoI is actually used; the two settings are therefore written as "RE10K, 256→512 (2×)" and "DL3DV, 256→1024 (4×)". Metrics are PSNR / SSIM / LPIPS computed inside the RoI mask.

Dataset / Setting Method PSNR↑ SSIM↑ LPIPS↓ Trainable Param. Train Time Memory # Gaussians
RE10K 256→512 (2×) pixelSplat low-res full 25.94 0.820 0.128 118M 0.89s 14.32G 393K
MVSplat low-res full 26.08 0.832 0.089 12M 0.49s 8.27G 131K
DepthSplat low-res full 27.28 0.852 0.101 120M 0.66s 8.90G 131K
MVSplat high-res full* 27.12 0.862 0.085 12M 1.15s 25.91G 524K
DepthSplat high-res full* 28.26 0.875 0.085 120M 2.03s 32.66G 524K
DepthSplat high-res crop 24.38 0.759 0.161 120M 0.78s 8.90G 131K
Ours 28.54 0.876 0.084 43M 1.74s 13.27G 214K
DL3DV 256→1024 (4×) DepthSplat low-res full 22.31 0.652 0.286 120M 0.91s 8.15G 131K
DepthSplat high-res full* OOM even on an 80GB H100 — — 120M — — —
DepthSplat high-res crop 19.51 0.571 0.352 120M 0.87s 8.10G 131K
Ours 23.74 0.721 0.225 43M 1.67s 9.46G 220K

The high-res full variants marked with * additionally consume full-size high-resolution context images, i.e. they have privileged information, and are not strictly comparable with this method. Time and memory are per-iteration training cost measured with batch size 1 on an NVIDIA A6000, not inference latency.

Zero-shot generalization (the model has only ever seen Gaussians predicted by DepthSplat, and is applied directly to other sources):

Dataset Source of input Gaussians Input PSNR / SSIM / LPIPS After densification PSNR↑ SSIM↑ LPIPS↓
RE10K 256→512 DepthSplat low-res full 27.28 / 0.852 / 0.101 28.54 (+1.26) 0.876 (+0.024) 0.084 (-0.017)
pixelSplat low-res full 25.94 / 0.820 / 0.128 27.09 (+1.15) 0.844 (+0.024) 0.108 (-0.020)
MVSplat low-res full 26.08 / 0.832 / 0.089 27.32 (+1.24) 0.853 (+0.021) 0.087 (-0.002)
DL3DV 256→1024 DepthSplat low-res full 22.31 / 0.652 / 0.286 23.74 (+1.43) 0.721 (+0.069) 0.225 (-0.061)
per-scene optim. 22.34 / 0.659 / 0.291 24.46 (+2.12) 0.742 (+0.083) 0.225 (-0.066)

Ablation Study

All models are trained and evaluated under the DL3DV 256→1024 setting; numbers in parentheses are gains over the initial Gaussians of that setting (PSNR 22.31).

Group Config PSNR↑ SSIM↑ LPIPS↓ Note
Source Gaussians input, 4× 23.27 (+0.96) 0.695 0.260 densify only input RoI Gaussians, \(K=4\)
input, 16× 23.25 (+0.94) 0.697 0.260 raising \(K\) to 16 brings no further gain
pixel 22.97 (+0.66) 0.694 0.248 densify only pixel-guided Gaussians
Ours (both) 23.74 (+1.43) 0.721 0.225 densify both sources together
Initial features no gradient 23.58 (+1.27) 0.713 0.233 removes gradient feature \(\nabla L\)
no recon. 23.31 (+1.00) 0.705 0.238 removes rendering-residual features
no multi-view 23.53 (+1.22) 0.710 0.235 removes multi-view features
Cross-attention no attention 22.65 (+0.34) 0.664 0.273 no image cross-attention at all
global 22.64 (+0.33) 0.663 0.274 global cross-attention (bottleneck)
last block 23.59 (+1.28) 0.716 0.230 projection-based attention at the last block only

Key Findings

  • A consistent gain of more than 1 dB over the initial low-resolution Gaussians: +1.26 dB on RE10K (27.28→28.54) and +1.43 dB on DL3DV (22.31→23.74), showing that high-resolution observations really are exploited rather than wasted by a uniform-resolution architecture.
  • It matches or beats even the privileged baseline: on RE10K, DepthSplat high-res full has access to full-size 512×512 context images yet reaches only 28.26 PSNR, below this method's 28.54 — while using 40% of the Gaussian budget (214K vs 524K), roughly a third of the trainable parameters (43M vs 120M), a shorter training step (1.74s vs 2.03s) and less than half the memory (13.27G vs 32.66G). Under the DL3DV 4× setting that baseline simply OOMs, exposing the scalability problem of the uniform-resolution route.
  • "High-resolution inputs on crops" is not a viable substitute: high-res crop is worst on both datasets, and on DL3DV its 19.51 is 2.8 dB below the low-resolution baseline of 22.31. The reason is that local crops overlap little and are off-center, so reliable multi-view geometry cannot be learned from them alone; the coarse 3D scaffold provided by the initial Gaussians is what aggregates the information.
  • Pixel-guided and input Gaussians are complementary, not interchangeable: input-only densification gives +0.96, pixel-only gives +0.66, and the two together give +1.43; moreover raising \(K\) from 4 to 16 changes nothing (23.27→23.25), showing that cloning the same coarse Gaussians harder is a dead end. Visualizations agree: the updated input Gaussians act mostly as a coarse backdrop while the sharp detail is rendered by the pixel-guided ones.
  • Explicit rendering residuals are the most valuable feature family: among the three initial feature families, removing the reconstruction-residual features costs the most (+1.00), clearly more than the gradient feature (+1.27) and the multi-view features (+1.22). This matches the design intent — effective residual learning presupposes explicitly associating Gaussians with images by rendering first.
  • The form of cross-attention matters more than its presence: no attention gives +0.34 and global attention +0.33, essentially equally bad; only projection-based (local) attention lifts the gain to +1.28, with multi-scale adding a further step to +1.43.
  • A better initialization yields a larger gain: on DL3DV, swapping the input for per-scene-optimized Gaussians widens this method's gain from +1.43 to +2.12 (22.34→24.46), indicating that the method is an amplifier rather than a repairer.

Highlights & Insights

  • It rewrites "high resolution" from a global budget problem into a local on-demand operation: previously, reconstructing at high resolution meant paying the cost everywhere; here a single 2D mask decides where compute is worth spending. That is a natural interaction primitive for interactive capture, product inspection, and document or signage reading. The problem formulation itself is more inspiring than the method.
  • Being source-agnostic is the key engineering advantage: methods such as Generative Densification must consume the latent features of the base feed-forward model and be jointly fine-tuned with it, whereas GaussianLens eats Gaussian parameters only, so it drops directly onto Gaussians from pixelSplat / MVSplat or even per-scene optimization (where it amplifies the gain to +2.12). Not assuming who the upstream model is makes the method far easier to plug into real systems.
  • The pixel-guided Gaussian initialization is nearly free yet highly effective: the color comes straight from the pixel, the position is the back-projection of the camera ray onto the coarse rendered depth, and opacity and scale are small constants — three steps produce tens of thousands of primitives carrying dense appearance, moving the hard question of "where does detail come from" from the network to the data. It also explains why \(K=1\) suffices: quantity is supplied by the pixels, so the network only has to correct.
  • "Feed rendering residuals back as features" is a reusable trick: in incremental or editing-based reconstruction (start coarse, upgrade locally), rendering, differencing against observations and encoding the difference back into the network is more stable than asking the network to infer the error from scratch. It shares its origin with G3R's use of rendering gradients, but here it is combined with multi-view image features.
  • Transferable directions: the same recipe — low-resolution scaffold + local high-resolution evidence + residual feed-forward densification — applies to online/streaming reconstruction (the user upgrades regions while browsing), on-demand refinement of large-scale city-level reconstructions, and local re-rendering after scene edits.

Limitations & Future Work

  • Limitations admitted by the authors: the model is designed to enhance detail on top of a coarse initial reconstruction and does not repair catastrophic errors already present in it. The authors' proposed future direction is to extract emerging geometry cues from high-resolution observations and use them to recover from reconstruction failures at low resolution — which effectively demands correction capability, not just densification.
  • Only two zoom factors are evaluated: 2× on RE10K and 4× on DL3DV, with nothing in between or beyond (e.g. 8×); since the number of pixel-guided Gaussians grows quadratically with the zoom factor, how the Gaussian budget and memory behave at higher factors is not reported.
  • The RoI generation differs from real user interaction: the paper's 3D RoIs are produced by sampling 2D crops from context views and back-projecting them (details in Supp. Sec. B.4), which is not the same as a user freely framing a region in an arbitrary current view; the effect of mask boundaries and RoI size is not ablated separately.
  • The high-resolution images are paired captures of the same scene: high-resolution and low-resolution observations in the datasets come from the same capture, with consistent viewpoint, exposure and lighting. In practice a user who wants to see detail often walks closer and shoots another photo, bringing distribution shifts in viewpoint, motion blur and exposure that are not evaluated here.
  • The gain depends on initialization quality: under zero-shot transfer the gains on pixelSplat / MVSplat (+1.15 / +1.24) are below that on the native DepthSplat (+1.26), while per-scene-optimized initialization reaches +2.12 — the ceiling of the method is bounded by the initial reconstruction, and if the initial geometry is globally off, local densification cannot rescue it (consistent with the authors' admitted limitation).
  • Training is not free: 1.67–1.74s per step and 9.5–13.3G of memory, higher than the low-resolution baselines (0.49–0.91s) because high-resolution inputs must be processed. It remains a bargain relative to globally high-resolution reconstruction, but it is still extra cost relative to low resolution alone, and whether it pays off depends on whether the application needs local detail.
  • vs DepthSplat / pixelSplat / MVSplat: all are single-pass, uniform-resolution, pixel- or voxel-aligned Gaussian predictors, so improving detail means raising the global resolution. This paper leaves them untouched and instead treats their output as a scaffold for local densification, which lets it exploit observations up to 1024×1024 — something these models cannot scale to themselves.
  • vs Generative Densification (GD): the closest work, aiming at the same uniform-resolution problem, but GD consumes the base feed-forward model's latent features, must be tailored to and jointly fine-tuned with it, and still performs single-pass image-to-Gaussian prediction for the whole scene. This paper takes Gaussians as input, assumes nothing about their source, and can densify exclusively inside a specified local region.
  • vs Adaptive Density Control in 3DGS: both rest on the intuition of densifying under-reconstructed regions, but ADC is a heuristic rule (gradient thresholds plus split/clone) requiring dense observations and per-scene offline optimization; this paper learns it as a one-step feed-forward prediction and adds pixel-guided Gaussians to solve "clone what" at large zoom factors.
  • vs multi-scale / hierarchical 3DGS (hierarchical 3DGS, Octree-GS, FLOD, etc.): they also deliver spatially varying detail, but level-of-detail selection happens at rendering time and training still requires offline optimization and storage of the full Gaussian hierarchy. This paper moves level-of-detail forward to the reconstruction stage, generating on demand rather than storing a hierarchy.
  • vs super-resolution and close-up novel view synthesis (SuperGaussian, Close-up-GS, SRGS, etc.): most distil 2D super-resolution models and optimize per scene; this paper does it in one forward pass, at the price of having no generative prior to fill in missing content.
  • vs LookCloser: the closest in goal — also exploiting local high-resolution observations while retaining global structure — but LookCloser is a frequency-aware radiance field with per-scene optimization, whereas this paper takes the generalizable Gaussian route: faster, but bounded by the quality of the initial reconstruction.

Rating

  • Novelty: ⭐⭐⭐⭐ The problem setting (on-demand localized densification) is new and targets a real bottleneck of uniform-resolution architectures; most components combine existing ideas, but pixel-guided densification is a genuinely original mechanism.
  • Experimental Thoroughness: ⭐⭐⭐⭐ Two datasets, a full comparison against fair and privileged baselines, three ablation groups (source Gaussians / initial features / attention form) plus zero-shot cross-source generalization make a complete evidence chain; the gaps are the two zoom factors only, and the distribution gap between generated RoIs and real interaction.
  • Writing Quality: ⭐⭐⭐⭐ The motivation (active human focus) is told clearly, each module's rationale maps onto an ablation, and the formulas are restrained; the main flaw is that key implementation details are pushed to the supplementary material, making the main text hard to reproduce from alone.
  • Value: ⭐⭐⭐⭐ It offers a deployable alternative paradigm for the very real pain of expensive high-resolution reconstruction, and its source-agnostic design makes it easy to adopt into existing feed-forward reconstruction systems; it is limited by enhancing rather than repairing, so its ceiling is tied to initial reconstruction quality.