Skip to content

G-ZAP: A Generalizable Zero-Shot Framework for Arbitrary-Scale Pansharpening

Conference: ECCV 2026
Paper: ECCV Original
Area: Remote Sensing
Keywords: pansharpening, zero-shot learning, arbitrary scale, implicit neural representation, cross-sensor generalization

TL;DR

G-ZAP uses a scale-conditioned implicit neural representation (INR) as its pansharpening fusion backbone, trained by a three-level collaborative scheme — an unsupervised spectral consistency loss at full resolution plus two levels of constructed supervision at reduced resolutions — so that a model trained on nothing but the test image pair itself produces HRMS output at any magnification, and the learned weights transfer directly to unseen image pairs, scenes, and sensors.

Background & Motivation

Satellite remote sensing is limited by hardware: it is impractical to acquire multispectral imagery that is simultaneously high in spatial and spectral resolution. The engineering compromise is to collect two complementary products — a low-resolution multispectral (LRMS) image and a high-resolution panchromatic (PAN) image — and pansharpening fuses them into a high-resolution multispectral (HRMS) image. The field has moved from model-driven approaches (component substitution, multi-resolution analysis, variational optimization) to data-driven deep learning, which clearly surpasses the classical methods in both spatial detail preservation and spectral fidelity, but almost always relies on large-scale pretraining over simulated reduced-resolution datasets.

The real problem shows up at deployment. A train–test distribution mismatch separates simulated reduced-resolution data from genuine full-resolution imagery, so models often fall short of their simulated-benchmark numbers on real full-resolution scenes, and the external paired data they need is expensive to obtain. Zero-shot pansharpening (PsDip, ZS-Pan and others) targets exactly this: it trains a model from scratch using a single input pair, sidestepping both external data and the distribution mismatch. But it pays for that by giving up efficiency — every new image pair requires re-optimizing a fresh set of parameters, so weights cannot be reused — and several methods additionally depend on an accurate estimate of spatial fidelity to balance spectral fidelity, which adds methodological complexity and compute. A third limitation is scale: most methods can only emit the fixed resolution tied to the PAN image size, whereas practical applications need a range of output resolutions, and a fixed scale directly costs fine detail.

Feature-based implicit neural representations (INRs) such as LIIF and its variants offer a different route: a shared continuous function space implicitly represents different images and naturally supports coordinate queries at arbitrary resolution, and INF³ and FeINFN have already brought INR formulations to image fusion. However, these methods still follow a pretraining–testing paradigm, need external data, and never address the fact that per-pair weights fail to transfer. This paper's angle is that since INR queries are scale-conditioned and the function space is shared, putting the INR directly into the zero-shot setting and designing a training scheme that aligns one parameter set across several resolutions should deliver all three properties at once: test-data-only training, arbitrary scale, and reusable weights. Core idea: take a feature-based INR fusion network (INRConv) as the backbone, use the sensor MTF to degrade the input into three resolution levels, enforce an unsupervised spectral consistency loss at the full-resolution level to align with real inference conditions, and turn the fact that "LRMS is by construction a downsampled PAN" into pseudo ground truth at the two reduced-resolution levels — so that one set of scale-conditioned weights stays valid at any magnification and can be reused across image pairs, scenes, and sensors.

Method

Overall Architecture

The inputs are a PAN image \(P\in\mathbb{R}^{H\times W}\), an LRMS image \(Y\in\mathbb{R}^{h\times w\times c}\), and a target magnification \(N\); the output is the corresponding HRMS image \(X_{\times N}\). The pipeline has two halves. The first is the INRConv fusion backbone: PAN is duplicated along the channel dimension to match the LRMS band count, LRMS is upsampled by \(r=H/h\) to PAN resolution, and the concatenation is encoded into a fused feature map defined on the discrete PAN grid; a target coordinate grid is then generated for the requested \(N\), each target point is answered by a four-neighbour point query with area-weighted aggregation, and two lightweight convolution layers decode the resulting dense features into HRMS. The second half is the training side: instead of external data, the model degrades this single PAN/LRMS pair into three resolution levels (full resolution, \(1/r\), \(1/r^2\)), all sharing one set of INRConv parameters, and jointly optimizes an unsupervised spectral consistency loss with two constructed supervision losses. Once trained, any value of \(N\) can be queried directly without retraining.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["PAN + LRMS pair<br/>+ target scale N"] --> B["Scale-conditioned implicit<br/>point-query fusion<br/>encode → 4-neighbour query<br/>area weighting → conv decode"]
    A --> C["Sensor MTF degradation<br/>builds 1/r and 1/r² inputs"]
    B --> D["Full-resolution spectral<br/>consistency constraint<br/>N=1 output MTF-degraded<br/>and downsampled vs LRMS"]
    C --> E["Multi-scale constructed<br/>supervision<br/>1/r level supervised by LRMS<br/>1/r² level constrains N=1 and N=4"]
    D --> F["Joint optimization of<br/>shared parameters"]
    E --> F
    F --> G["Weight reuse<br/>one set of weights across<br/>pairs, scenes, sensors"]
    G --> H["Arbitrary-scale HRMS×N output"]

Key Designs

1. Scale-conditioned implicit point-query fusion: make the magnification an input to the MLP rather than something baked into convolution kernels

A convolutional network bakes its output resolution into its weights — the kernel size and stride of a transposed convolution determine the one magnification it can produce, so a different scale means a different model. Existing INR fusion methods can query arbitrary coordinates, but they all sit inside a pretraining paradigm and need substantial paired data before generalization is even on the table. G-ZAP wants "one set of weights + arbitrary scale + training only on the test pair," which forces the scale to be an input condition of the model rather than a structural constraint.

Concretely, an EDSR-based encoder takes the channel-duplicated PAN together with the upsampled LRMS and encodes a fused feature map \(\mathcal{F}\) defined on the discrete PAN grid. Given a target magnification \(N\), a grid of \(HN\times WN\) target coordinates is generated on the normalized domain \([-1,1]^2\). For each target point \(q\), its four nearest neighbours \(z_t\) in the \(\mathcal{F}\) grid are located (top-left, top-right, bottom-left, bottom-right), and instead of a plain bilinear interpolation, a small MLP receives three things at once: the local feature \(\mathcal{F}(z_t)\) at that neighbour, the offset \(q-z_t\) of the target point relative to it, and the cell size \(s\) that encodes the target magnification \(N\). It outputs a latent response \(v_t\) for that neighbour, and the four responses are combined by area-weighted aggregation:

\[f(q)=\sum_{t\in\{00,01,10,11\}}\frac{S_t}{S}\,\mathbf{v}_t,\qquad S=\sum_t S_t\]

where \(S_t\) is the diagonal sub-area associated with neighbour \(z_t\). Querying all target coordinates in parallel yields a dense feature map at the target resolution, which two lightweight convolution layers decode into HRMS.

The cell size \(s\) is what makes this work: it tells the MLP explicitly how much ground one feature point has to cover, so the same parameters receive a different scale condition at different \(N\) and can produce outputs that are coherent and correct at each. Area-weighted aggregation then lets multiple target points that share a cell at low magnification inherit that cell's coverage naturally, avoiding the aliasing that direct coordinate queries tend to produce at small scale factors. Placing the convolution layers after the MLP rather than before is deliberate — following the observation in INF³, lightweight convolutions alleviate INR overfitting, and under a zero-shot setting overfitting is close to the most fatal failure mode there is.

2. Full-resolution spectral consistency: self-consistency at the real inference resolution, with no spatial fidelity term at all

The hardest level for any zero-shot method is full resolution, where no ground truth exists. Prior work either introduces complex spatial fidelity modelling (which additionally has to be estimated accurately) or simply abandons full-resolution supervision and trains only at reduced resolution, which walks straight back into the distribution mismatch. G-ZAP's choice is to add exactly one interpretable, nearly free spectral consistency constraint at the resolution it will actually be deployed at, and to leave spatial fidelity untouched.

At Level 0, INRConv processes the original-resolution \(P\) and \(Y\) with \(N=1\) to produce a full-resolution HRMS estimate. That estimate is then blurred by the sensor-specific MTF (modulation transfer function) and downsampled to LRMS resolution, and the result is required to match the observed LRMS input, measured with \(\ell_1\):

\[\mathcal{L}_{(0)}=\bigl\|\downarrow\!\bigl(\mathrm{MTF}\bigl(\mathcal{N}_\theta(P,Y,1)\bigr)\bigr)-Y\bigr\|_1\]

(This equation was corrupted in the cached LaTeX extraction and is reconstructed from the prose description ⚠️ refer to the original paper.) The constraint only asks that the full-resolution output still agree with the observation once degraded back to low resolution. It needs no ground truth and deliberately introduces no spatial fidelity term — this is precisely the paper's third stated contribution, obtaining better results without relying on a spatial fidelity constraint. The ablation confirms its weight: removing \(\mathcal{L}_{(0)}\) costs the most (WV3 HQNR falls from 0.9585 to 0.9276; WV2 from 0.9226 to 0.8781). The MTF here is more than a blur kernel: it is a sensor-dependent degradation operator shared by L0/L1/L2, which keeps all three levels consistent with the real sensor and means no degradation model has to be relearned when transferring across sensors.

3. Multi-scale constructed supervision: pinning down the 4× and 16× scale relations with pseudo ground truth grown from degradation

With Level 0 alone, the model never encounters a case where the input resolution is lower than the output resolution, so the cell-size condition of the INR is effectively never exercised; yet piling on reduced-resolution training alone would push the model back toward a distribution that mismatches real inference. The compromise is constructed supervision, which exploits a structural fact specific to pansharpening: LRMS is by construction a downsampled version of PAN, so degrading PAN and LRMS together by one more step automatically yields a legitimate reference — aligned paired supervision with no external data at all.

Level 1 blurs \(P\) and \(Y\) with the sensor MTF and downsamples them by \(r\) to get \(P_{1/r}\) and \(Y_{1/r}\), has INRConv reconstruct them at \(N=1\), and supervises the output against the original LRMS image \(Y\) (\(P_{1/r}\) has resolution \(h\times w\), exactly matching \(Y\), so the supervision is perfectly aligned). Level 2 degrades the Level-1 inputs one more step to obtain \(P_{1/r^2}\) and \(Y_{1/r^2}\), then runs two branches at once: the \(N=1\) output is aligned with \(Y_{1/r}\), and the \(N=4\) output is aligned directly with the original \(Y\):

\[\mathcal{L}_{(2)}=\bigl\|\mathcal{N}_\theta(P_{1/r^2},Y_{1/r^2},1)-Y_{1/r}\bigr\|_1+\bigl\|\mathcal{N}_\theta(P_{1/r^2},Y_{1/r^2},4)-Y\bigr\|_1\]

(Also reconstructed from the prose ⚠️ refer to the original paper.) With \(r=4\), the Level-2 input carries only \(1/16\) of PAN resolution, while the \(N=4\) branch demands that it be reconstructed to \(h\times w\). This level therefore both reasserts the 4× relation learned at Level 1 and folds the 16× scale span relative to full-resolution Level 0 into training: one function space must satisfy several (input resolution → output resolution) mappings simultaneously, which is when the cell-size condition genuinely starts to matter and become sensitive. The ablation shows \(\mathcal{L}_{(2)}\) has the smallest individual contribution (WV3 HQNR drops only 0.0074), but what it protects is sharpness at high magnification — without it, textures in high-resolution regions visibly blur and fine structures disappear.

4. Weight reuse: amortize per-pair optimization into one training run, and gain better cross-sensor behaviour as a side effect

Zero-shot's freedom from paired data is bought with per-pair retraining: roughly 285 s per pair for PsDip, 463 s for UCL, 67 s for ZS-Pan, all of which restart from scratch on the next pair so the cost can never be amortized. Remote sensing imagery, however, is highly similar in structure and texture across scenes, which suggests weights need not be tied to any single pair.

Once trained, G-ZAP's weights transfer as-is to unseen pairs: in the 8-band setting, a model trained on WV3 is used directly for inference on both WV3 and WV2 with no retraining, and in the 4-band setting a model trained on GF2 serves every test pair (this variant is denoted G-ZAP∗). Training cost is thereby spread across many images, and per-image inference drops to 4.23 s (WV3) and 0.14 s (WV2). The authors attribute this transferability to the feature-based INR formulation: compared with purely convolutional features it can be viewed as a more expressive interpolation mechanism that better exploits the structural and textural commonality shared across remote sensing scenes, and is therefore also more stable when image characteristics change, as they do across sensors. The clearest evidence comes from the backbone swap ablation — replacing INRConv with the purely convolutional FusionNet while leaving everything else unchanged makes FusionNet degrade noticeably in the WV2 weight-reuse setting relative to its own per-pair training, whereas INRConv stays stable.

A Worked Example

Take a WV3 pair from PanCollection: PAN cropped to \(512\times512\) with 8 bands, \(r=4\), hence LRMS at \(128\times128\).

Level 0 uses the original \(P\ (512\times512)\) and \(Y\ (128\times128)\) with \(N=1\), producing \(512\times512\), which is MTF-blurred and downsampled to \(128\times128\) for the \(\ell_1\) comparison against \(Y\). Level 1 degrades \(P\) and \(Y\) by one step to \(P_{1/4}\ (128\times128)\) and \(Y_{1/4}\ (32\times32)\), produces \(128\times128\) at \(N=1\), and compares against \(Y\). Level 2 degrades one more step to \(P_{1/16}\ (32\times32)\) and \(Y_{1/16}\ (8\times8)\) and evaluates both branches: the \(N=1\) output of \(32\times32\) against \(Y_{1/4}\), and the \(N=4\) output of \(128\times128\) against \(Y\).

The three levels differ in input resolution, supervision target, and \(N\) setting, but they use the same INRConv parameters — each step only swaps the inputs and the scale configuration. After training on this one pair, setting \(N\) to 1.6, 2, 3.4, 4 or any other value lets the same weights emit HRMS at that resolution directly, which is also why they can be moved onto the entirely unseen WV2. The whole pipeline uses only this one pair, with no external HR/LR pairs anywhere.

Loss & Training

The total objective is the weighted sum of the three levels: \(\mathcal{L}_{\text{total}}=\alpha\,\mathcal{L}_{(0)}+\beta\,\mathcal{L}_{(1)}+\gamma\,\mathcal{L}_{(2)}\). The weights are \(\alpha=\beta=1\), with \(\gamma=0.2\) in the 8-band setting and \(\gamma=4\) in the 4-band setting (the paper gives no explanation for the 20-fold difference ⚠️ refer to the original paper). Optimization uses Adam with an initial learning rate of \(5\times10^{-4}\) for 500 epochs on a single NVIDIA RTX 3090 (24 GB) with an AMD EPYC 7402. For reference, the pretrained deep baselines use only the WV3 and GF2 training sets (corresponding to the 8-band and 4-band configurations respectively), whereas G-ZAP starts from the test PAN/LRMS pair alone and uses no external HR/LR pairs.

Key Experimental Results

Main Results

Experiments use three datasets from PanCollection — WorldView-3 (WV3), GaoFen-2 (GF2), and WorldView-2 (WV2) — with PAN cropped to \(512\times512\); WV3 and WV2 have 8 spectral bands and GF2 has 4. Because the target is real-world pansharpening without ground truth, evaluation is mainly performed at full resolution with three no-reference metrics: HQNR (a composite that combines \(D_s\) and \(D_\lambda\)), \(D_s\) (spatial distortion, lower is better), and \(D_\lambda\) (spectral distortion, lower is better). Baselines span traditional methods (BT-H, C-BDSD, BDSD-PC, MTF-GLP-FS, MF), pretrained deep models (FusionNet, LAGNet, FusionMamba, WFANet), and zero-shot methods (PsDip, ZS-Pan, UCL). G-ZAP∗ is the weight-reuse variant: in the 8-band setting the model trained on WV3 (id=0) is used directly on WV3 and WV2, and in the 4-band setting the GF2 (id=0) model serves all test pairs.

The table below compares against the previous SOTA on each dataset (the strongest non-G-ZAP method; bold = best, underline = second best):

Dataset Method HQNR↑ \(D_\lambda\)↓ \(D_s\)↓
GF2 (4-band, in-domain) FusionMamba (prev. SOTA) 0.9536 0.0174 0.0295
GF2 G-ZAP∗ (weight reuse) 0.9569 0.0188 0.0246
GF2 G-ZAP 0.9706 0.0181 0.0115
WV3 (8-band, in-domain) FusionMamba (prev. SOTA) 0.9550 0.0183 0.0272
WV3 G-ZAP∗ 0.9574 0.0187 0.0244
WV3 G-ZAP 0.9585 0.0187 0.0233
WV2 (cross-sensor) UCL (strongest zero-shot baseline) 0.9201 0.0228 0.0585
WV2 G-ZAP 0.9226 0.0304 0.0486
WV2 G-ZAP∗ 0.9367 0.0195 0.0450

Ablation Study

Removing each loss term in turn while keeping everything else unchanged, evaluated on WV3 (in-domain) and WV2 (cross-sensor):

Config HQNR↑ (WV3 / WV2) \(D_\lambda\)↓ (WV3 / WV2) \(D_s\)↓ (WV3 / WV2) Note
G-ZAP (full) 0.9585 / 0.9226 0.0187 / 0.0304 0.0233 / 0.0486 all three losses on
w/o \(\mathcal{L}_{(0)}\) 0.9276 / 0.8781 0.0279 / 0.0496 0.0459 / 0.0760 no full-resolution spectral consistency; largest drop
w/o \(\mathcal{L}_{(1)}\) 0.9377 / 0.8970 0.0181 / 0.0313 0.0451 / 0.0743 no \(1/r\) constructed supervision; spatial distortion worsens sharply
w/o \(\mathcal{L}_{(2)}\) 0.9511 / 0.9178 0.0185 / 0.0264 0.0310 / 0.0574 no \(1/r^2\) multi-scale supervision; smallest drop but details blur

A second comparison covers runtime against zero-shot methods (seconds, lower is better):

Method WV3 time↓ WV3 HQNR↑ WV2 time↓ WV2 HQNR↑
PsDip 285.37 0.9215 280.23 0.8980
ZS-Pan 67.24 0.9449 68.52 0.9112
UCL 463.22 0.9482 464.41 0.9201
G-ZAP (per-pair training) 79.03 0.9585 78.58 0.9226
G-ZAP∗ (weight reuse) 4.23 0.9574 0.14 0.9367

Key Findings

  • Level 0 is the least replaceable of the three: removing it costs 0.0309 HQNR on WV3 and 0.0445 on WV2, with both \(D_\lambda\) and \(D_s\) worsening at once. Adding a self-consistency constraint at the true inference resolution is more effective than simply adding more reduced-resolution supervision, which supports the principle that training conditions should be aligned with deployment conditions.
  • The three levels have distinct roles rather than simply summing: removing \(\mathcal{L}_{(1)}\) actually gives a slightly better \(D_\lambda\) on WV3 than the full model (0.0181 vs 0.0187), but \(D_s\) degrades from 0.0233 to 0.0451 — the \(1/r\) level contributes mainly to spatial detail, not spectral fidelity. The three levels respectively hold distribution alignment, spatial alignment, and scale alignment.
  • Weight reuse does more than hold steady across sensors — it can beat per-pair training: on WV2, G-ZAP∗ reaches HQNR 0.9367 against G-ZAP's 0.9226 (on in-domain WV3 the two are close: 0.9574 vs 0.9585) ⚠️ the paper reports the numbers without explaining this. One possible reason is that the self-supervision signal available from a single WV2 pair is weaker than the generic prior already learned on WV3, but that is speculation.
  • The backbone swap is the key evidence for reusability: under identical settings, replacing INRConv with the purely convolutional FusionNet makes the latter degrade noticeably on WV2 under weight reuse relative to its own per-pair training, while INRConv stays stable — supporting the explanation that a feature-based INR is a stronger interpolation mechanism and therefore more transferable.
  • The efficiency advantage comes entirely from weight reuse, not from faster single training: per-pair G-ZAP takes 79.03 s on WV3, actually slower than ZS-Pan's 67.24 s; only G-ZAP∗ reaches 4.23 s / 0.14 s. The claim of "only a few seconds or even sub-second" holds only for the weight-reuse variant.
  • High-magnification sharpness depends on \(\mathcal{L}_{(2)}\): removing it turns high-resolution textures blurry and loses fine structures, yet HQNR drops only 0.0074, suggesting this loss shows up more in visual detail than in the no-reference metrics.

Highlights & Insights

  • Arbitrary scale as an input condition rather than a structural constraint: feeding cell size \(s\) alongside the relative coordinate means magnification is encoded in the query itself, so one set of weights covers a continuum of scales. This is cleaner than training a model per scale or doing fixed-scale plus post-hoc resizing, and it composes naturally with multi-level training, since different levels already correspond to different \(s\).
  • Constructed supervision exploits a redundancy inherent to the task: LRMS is by construction a downsampled PAN, so degrading the two together by one more step manufactures an aligned pseudo ground truth from nothing. The trick needs no external data and adds no new assumption; it should transfer to any task where two paired modalities have a fixed resolution ratio (hyperspectral–multispectral fusion, depth–RGB, multimodal medical imaging).
  • Deliberately omitting a spatial fidelity term is a substantive design decision: prior zero-shot methods estimate spatial fidelity to balance spectral fidelity, whereas this paper shows that a suitable three-level training scheme makes spectral consistency plus constructed supervision sufficient — removing an error source and extra compute at once.
  • The way weight reuse is argued is worth borrowing: rather than only reporting "little degradation under reuse," the authors run a swap-backbone control, turning "INR buys transferability" from a claim into a falsifiable piece of evidence.
  • Transferable to per-sample self-supervised tasks in general: any setting that optimizes per sample without ground truth (internal-learning super-resolution, single-image denoising, test-time adaptation) can ask the same question — if the objective is split into several constructible levels and a shared function space is introduced, can per-sample optimization be replaced by "train once, then reuse the weights"?

Limitations & Future Work

  • Per-pair training is still not cheap: G-ZAP itself takes 79.03 s per pair, slower than ZS-Pan's 67.24 s, and on cross-sensor data it does not always beat its own weight-reuse variant. The paper attributes efficiency to G-ZAP∗, but G-ZAP∗ introduces a new hyper-parameter — which pair to use as the seed — and the paper fixes it to id=0 without analysing the choice.
  • Arbitrary scale has visual evidence only: results at ×1, ×1.6, ×2, ×3.4 and ×4 are shown as visual samples with no quantitative metric. The reason is that no-reference full-resolution metrics such as HQNR/\(D_s\)/\(D_\lambda\) are defined at a fixed resolution, but the paper could still have used degradation-then-evaluation or cross-scale self-consistency as a numerical signal; as it stands, the magnitude of numeric degradation at high magnification cannot be judged.
  • Cross-sensor validation covers a single combination: only 8-band WV3 → 8-band WV2 is tested. Whether weights transfer between sensors with different band counts (4-band ↔ 8-band), and whether the encoder must be retrained per band count, is not discussed; the two \(\gamma\) values (0.2 for 8 bands, 4 for 4 bands, a 20-fold spread) hint that band count does change how sensitive the losses are, which the paper also leaves unexplained.
  • Narrow evaluation suite: only HQNR, \(D_s\) and \(D_\lambda\) are reported at full resolution (and they are not independent — HQNR is composed of the other two), with no cross-validation against other no-reference frameworks and no variance over repeated runs, so it is impossible to tell whether differences at the 0.001–0.005 level are stable.
  • Possible improvements: extend constructed supervision to non-integer degradation factors (the degradation chain is currently \(r\) and \(r^2\), hard-wired to the \(N=1,4\) settings used in training) so that the scale condition becomes genuinely continuous during training; add a lightweight meta-learning or adaptation step on top of weight reuse so the transferred weights can take a few gradient steps toward the target sensor, trading a little efficiency for cross-sensor accuracy; and turn "which pair to use as the seed" into an optimizable selection problem.
  • vs ZS-Pan / PsDip (conventional zero-shot): they also train at test time without external data, but differ on three counts — they retrain per image pair (on the order of 285 s / 67 s) whereas this paper trains once and reuses; they rely on spatial fidelity estimation to balance spectral fidelity whereas this paper uses spectral consistency plus constructed supervision; and they are fixed at the resolution implied by PAN whereas this paper supports arbitrary magnification.
  • vs UCL (a variational zero-shot framework with unsupervised coefficient learning): on WV2, UCL's HQNR of 0.9201 is close to G-ZAP's 0.9226, but UCL takes 463.22 s per pair, orders of magnitude above G-ZAP∗'s 0.14 s; the gap here is mainly about deployability rather than accuracy.
  • vs INF³ / FeINFN (feature-based INR fusion): the backbone design is of the same lineage (an INR query followed by lightweight convolutions to curb overfitting), but those methods follow a pretraining–testing paradigm and need external data; this paper moves the INR into the zero-shot setting and repurposes the scale condition for multi-level cooperative training.
  • vs LIIF / UltraSR (feature-based INR super-resolution): it inherits the local implicit image function skeleton with four neighbours and area-weighted aggregation, but extends single-input super-resolution to a two-input PAN/LRMS fusion problem, and upgrades cell size from a mere scale encoding to the coupling point of cross-resolution training.
  • vs FusionNet / FusionMamba / WFANet (pretrained deep models): these train on simulated reduced-resolution data and are strong on simulated benchmarks, yet in this paper's ablation FusionNet degrades noticeably as soon as it is moved into the cross-sensor weight-reuse setting — suggesting the generalization bottleneck of the pretraining paradigm lies not only in data volume but also in the transferability of purely convolutional features.

Rating

  • Novelty: ⭐⭐⭐⭐ Combining a feature-based INR with zero-shot pansharpening, plus the three-level cooperative training and weight reuse, is a substantively new combination, and making scale a query condition is more principled than training a model per scale.
  • Experimental Thoroughness: ⭐⭐⭐ Three real datasets, four baseline families, and three ablation axes (loss terms, backbone, runtime) give decent coverage, but arbitrary scale lacks quantitative evaluation, cross-sensor is validated on one combination only, no variance is reported, and the fact that per-pair training is not actually faster is presented somewhat optimistically.
  • Writing Quality: ⭐⭐⭐ The division of labour across the three levels is clearly explained and the framework figure and loss definitions are complete, but several equations are lost in typesetting and some design choices (the \(\gamma\) discrepancy, weight reuse beating per-pair training on WV2) go unexplained.
  • Value: ⭐⭐⭐⭐ "Train once, reuse across images and sensors, any scale" is attractive for real remote sensing deployment, and the constructed-supervision idea transfers directly to other multi-resolution fusion tasks.