Weighted Strong Product Graph Laplacian Regularization for Hyperspectral Image Mixed-Noise Removal with Superpixel Segmentation

Highlights

What are the main findings?

• The Kronecker product graph used by prior superpixel/band-segmented HSI denoisers omits the pure-spatial and pure-spectral edges; restoring them through a weighted strong product graph improves Mean Peak Signal-to-Noise Ratio (MPSNR) and Erreur Relative Globale Adimensionnelle de Synthèse (ERGAS) in all 12 simulated dataset–case settings—by up to 2.5 dB in MPSNR from the graph term alone.
• The product-graph edge type governs a spatial–spectral fidelity trade-off: pure edges drive spatial reconstruction while joint edges favour spectral fidelity (Spectral Angle Mapper, SAM), and the trade-off is tunable by a single weight β.

What are the implications of the main findings?

• For this model family, Cartesian/strong-type products retain the pure spatial and spectral edges that the Kronecker product alone omits.
• The low-rank block of the framework is modular (matrix or Tucker), allowing the prior to be matched to scene structure.

Abstract

Hyperspectral images (HSIs) are inevitably degraded by mixed noise, which hampers downstream interpretation. Recent graph-signal-processing denoisers encode the spatial–spectral structure of an HSI through a product graph over superpixel bodies, yet the adopted Kronecker (tensor) product graph retains only the joint spatial–spectral edges and discards the pure-spatial and pure-spectral edges—the two priors that govern HSI smoothness. We introduce a two-parameter weighted product-graph family that contains the Kronecker, Cartesian and strong products as exact special cases, and propose Weighted Strong Product Graph Laplacian Regularization (WSPGLR)—the strong-product branch with a tunable joint-edge weight β—embedded in a global low-rank plus sparse model solved by the Alternating Direction Method of Multipliers (ADMM) with singular-value-thresholding and soft-thresholding updates and a sparse conjugate-gradient (CG) solve. On three simulated cubes (Washington DC Mall, Pavia University, Indian Pines) under four mixed-noise scenarios, WSPGLR consistently improves Mean Peak Signal-to-Noise Ratio (MPSNR) and ERGAS (Erreur Relative Globale Adimensionnelle de Synthèse) over a matched Kronecker-product control in every tested case (and Mean Structural Similarity (MSSIM) in 11 of 12 settings)—up to 2.5 dB in MPSNR from the graph term alone—and an ablation shows that β governs a spatial–spectral fidelity trade-off (Spectral Angle Mapper, SAM). On the detailed urban scenes, WSPGLR attains the highest MPSNR against the external methods and matched control in seven of eight settings, whereas it trails LRTDTV on the smooth agricultural scene; with an optional scene-adaptive TV step it attains the best average rank across scene types; a Tucker-based variant further shows the low-rank block is modular and generally improves spectral fidelity. Tests on four no-reference real HSIs and 30 paired real-noise MEHSI samples extend the sensor coverage; on MEHSI, the native-domain RND framework remains substantially stronger, which delimits the scope of the proposed training-free regularizer.

1. Introduction

Hyperspectral images (HSIs) record hundreds of contiguous narrow spectral bands for every spatial location, providing rich spectral signatures that underpin mineral exploration, precision agriculture, environmental monitoring, land-cover mapping and reconnaissance [1,2]. Because the incoming radiance is divided among many narrow bands, the photon count per band is low, so sensor noise is in part signal-dependent (Poissonian shot noise superposed on a signal-independent Gaussian read/dark-current floor, with both terms varying by band and by sensor) [3], and acquired HSIs are further affected by dark current, calibration errors and push-broom scanning artifacts. The result is a mixture of noise types—zero-mean Gaussian noise, impulse (salt-and-pepper) noise, stripes and dead lines—whose statistics moreover vary from band to band [4,5]. Following common practice in the compared low-rank/graph literature, our simulated benchmark (Section 4.1) approximates this mixture with band-varying additive Gaussian and impulse noise; Section 4.6 additionally reports a physically motivated signal-dependent (Poisson–Gaussian) regime and a lower-severity case to test whether the graph-control margin persists beyond the main noise model and severity range. Removing this mixed noise without destroying the fine spatial structure and the spectral signatures is a prerequisite for reliable downstream analysis.

Three decades of research on HSI denoising can be read as a search for the right prior. Early approaches applied mature two-dimensional filters band by band—for example, the collaborative transform-domain filter BM3D [6]—but band-wise processing ignores the strong correlation among bands; volumetric extensions such as BM4D [7] treat the cube as a whole yet remain agnostic to the specific spatial–spectral anisotropy of HSIs. A second line exploits the fact that clean spectra lie near a low-dimensional subspace: low-rank tensor approximation (LRTA) [8] and PARAFAC decomposition [9] impose multilinear low-rankness, while low-rank matrix recovery (LRMR) [4] casts mixed-noise removal as robust principal component analysis on the unfolded cube and NAILRMA [5] iteratively refines a noise-adjusted low-rank approximation to accommodate band-dependent noise levels. Because low-rankness alone leaves residual spatial noise, a third line couples it with total variation (TV): LRTV [10] combines low-rank matrix factorization with spatial TV, spatio-spectral TV (SSTV) regularizes the spectral gradient as well [11], LRTDTV embeds an anisotropic SSTV in a Tucker decomposition [12], LLRGTV balances local low-rank patches against a global SSTV [13], and a recast total-variation formulation unifies the two terms [14]. A fourth line denoises the coefficients of a learned spectral subspace—FastHyDe [15] filters eigen-images non-locally, GLF adds global-and-non-local low-rank factorizations [16], NGmeet iterates between the subspace and non-local patch estimation [17], and TSLRLN lifts the construction to tensor subspaces [18]. Finally, deep networks learn spatial–spectral priors from data: HSID-CNN [19], HSI-DeNet [20] and QRNN3D [21] employ convolutional and recurrent architectures, while more recent work uses spectral-enhanced transformers [22] and self-supervised denoising diffusion models that operate on the degraded image alone [23]. Deep models are strong when training and test distributions match, but they require external training data (or costly per-image optimization) and their behavior on unseen sensors or noise mixtures is harder to control than that of model-based schemes; see [24] for a recent systematic review of the model-based (low-rank tensor) line.

A more recent, structurally different line models the HSI with tools from graph signal processing (GSP) [25,26,27]: pixels (or superpixels) are graph nodes, affinities are edges, and the graph Laplacian regularizer (GLR) ${\mathit{x}}^{\top }\mathit{L}\mathit{x}$ penalizes signal variation across connected nodes, which naturally accommodates the irregular regions produced by superpixel segmentation [28,29,30]. For multi-way data, product graphs offer a principled and scalable way to compose a graph per dimension into a joint model [31,32]: Kronecker products model recursive network structure [33], Cartesian product factors can be learned from multi-domain data [34], and graph products underpin spatio-temporal feature learning [35]. In HSI denoising specifically, the research group behind the present line of work introduced an adaptive-weight graph TV coupled with low-rank recovery [36], a large-scale distributed superpixel-based GSP restoration framework [37], then KGLRSSBS, which combines superpixel segmentation, band segmentation and a Kronecker product graph over superpixel bodies [38], and most recently LRTDKGLR, which couples the same Kronecker product-graph regularizer with a Tucker tensor decomposition [39]. A particularly relevant 2026 development is PCC-GLR [40], which constructs global and local spectral graphs from Pearson correlations and combines them with low-rank and sparse-noise terms. Notably, the strong product graph itself has been used by the same group for time-varying graph-signal inpainting [41], but it has not been explored as a spatial–spectral regularizer for HSI denoising.

Motivation. While the Kronecker product elegantly couples the two dimensions, it is too restrictive. In ${\mathcal{G}}_c\otimes {\mathcal{G}}_p$, two nodes $(u_1,v_1)$ and $(u_2,v_2)$ are adjacent only if $u_1\sim u_2$ and $v_1\sim v_2$; only “neighboring-pixel-and-neighboring-band” edges survive. Consequently the Kronecker graph carries neither (i) pure-spatial edges—neighboring pixels within the same band ($u_1\sim u_2$, $v_1=v_2$), the dominant spatial-smoothness prior—nor (ii) pure-spectral edges—the same pixel across adjacent bands ($u_1=u_2$, $v_1\sim v_2$), the most characteristic HSI prior. Both are discarded exactly where HSI signals are smoothest, and the tensor product of two connected graphs is frequently disconnected, weakening diffusion of the regularizer. Our experiments confirm that the Kronecker graph is the weakest of the canonical product graphs on the spatial-reconstruction metrics (Section 4.5).

Contribution. We argue that the strong product graph ${\mathcal{G}}_c⊠{\mathcal{G}}_p$, whose edge set is the union of the Cartesian and tensor products [31], is the natural remedy: it reinstates the pure-spatial and pure-spectral edges while keeping the joint edges. To study the two edge groups systematically we cast them in a two-parameter weighted product family ${\mathit{A}}_{\alpha ,\beta }$ (Section 3.3), in which the pure edges carry a weight $\alpha$ and the joint edges a weight $\beta$; the Kronecker $(\alpha ,\beta )=(0,1)$, Cartesian $(1,0)$ and strong $(1,1)$ products are exact special cases. The proposed WSPGLR keeps the pure edges ($\alpha =1$) and tunes the single joint-edge weight $\beta$, thereby spanning the Cartesian and strong products. Our contributions are:

1.

We introduce WSPGLR, a weighted strong-product graph Laplacian regularizer for HSI denoising, built on a two-parameter product family that contains the Kronecker, Cartesian and strong products as exact special cases, with a closed-form (normalized) Laplacian.

2.

We embed WSPGLR in a global low-rank plus sparse model whose spatial graph is assembled per superpixel to preserve boundaries, and derive an ADMM solver whose graph subproblem is a sparse linear system solved iteratively by conjugate gradients.

3.

Through an ablation over Kronecker/Cartesian/strong/weighted products and comparisons on simulated and real HSIs, we show that restoring the pure spatial–spectral edges yields consistent gains over the matched Kronecker baseline, and we benchmark the resulting method against representative model-based and learned denoisers.

4.

We demonstrate that the low-rank block is modular via a Tucker tensor variant (WSPGLR-T) that improves spectral fidelity in nearly all settings, and use it for a controlled comparison isolating “graph smoother versus spatial–spectral TV” under an identical tensor prior.

2. Related Work

Low-rank matrix and tensor models. The observation that clean spectra occupy a low-dimensional subspace motivates low-rank restoration. On the matrix side, LRMR performs patch-wise robust PCA on the unfolded cube [4]; NAILRMA adapts the approximation iteratively to band-dependent noise [5]; LRTV augments low-rank factorization with spatial TV [10]. On the tensor side, LRTA applies Tucker-based multilinear approximation [8], PARAFAC imposes a canonical polyadic structure [9], LRTDTV couples Tucker low-rankness with anisotropic spatio-spectral TV [12], and LLRGTV combines local low-rank patches with a global SSTV [13]; SSTV itself regularizes spatial and spectral gradients jointly [11], and recast formulations unify low-rank and TV terms in a single functional [14]. These priors are strong for Gaussian and sparse noise but tend to over-smooth textures, and their regularizers act on regular grids rather than on the irregular regions present in natural scenes.

Subspace and non-local methods. BM4D extends non-local collaborative filtering to volumetric data [7]. Subspace methods first estimate a spectral basis and then denoise the low-dimensional eigen-images: FastHyDe exploits their high spatial correlation [15], GLF combines global and non-local low-rank factorizations [16], NGmeet alternates between subspace estimation and non-local patch denoising [17], and TSLRLN performs the construction in a tensor subspace with a non-local prior [18]. Such methods achieve high spectral fidelity but depend on accurate subspace and noise estimation, and their piecewise-smooth assumptions favour homogeneous scenes.

Deep-learning methods. HSID-CNN learns a spatial–spectral residual mapping [19], HSI-DeNet learns multi-channel filter banks for restoration [20], and QRNN3D introduces 3-D quasi-recurrent units that propagate information along the spectral dimension [21]. More recently, state-space (Mamba) architectures have been applied to HSI denoising: SSUMamba scans the cube along six spatial–spectral orders with a bidirectional selective state-space model [42], and hybrid transformer–diffusion designs such as S2TDM combine spatial–spectral self-attention with a diffusion prior for the same task [43]. Deep models attain excellent accuracy within their training distribution, at the cost of external training data, limited interpretability, and uncertain generalization to unseen sensors and noise mixtures—which keeps interpretable model-based approaches, including the present one, practically relevant. The empirical comparison includes HSDT [44], a 2023 spectral-attention transformer evaluated with its openly downloadable checkpoint. Its guided spectral self-attention module is run in the released flex mode, a band-count-agnostic dot-product formulation that accepts our 103–224-band cubes without changing checkpoint weights. QRNN3D [21], a 2021 quasi-recurrent 3-D network, is evaluated with its released complex-noise checkpoint; its fully convolutional architecture is band-count-agnostic and requires no inference adaptation. Section 4.2 reports the resulting full comparison against both and against two distinct 2025 models: the multi-prompt transformer MP-HSIR and the transformer–diffusion model S2TDM. The same benchmark also includes PCC-GLR, the 2026 model-driven Pearson spectral-graph method most closely related to our graph regularization setting. To complement their out-of-domain evaluation, Section 4.8 also compares against RND [45], a 2026 real-noise-decoupling framework, on the official held-out test split of its native MEHSI evaluation domain.

Graph and product-graph methods. GSP provides the notion of signal smoothness on irregular domains [25,26], with applications from geometric data [27] to large multi-domain data via product graphs [32]. The algebra of graph products—Cartesian, tensor (Kronecker) and strong—is classical [31]; Kronecker products model recursive real-world networks [33], Cartesian factors can be learned from data [34], and graph products support spatio-temporal representation learning [35]. For HSI denoising, superpixel segmentation supplies edge-preserving regions [28,29,30], and graph-driven TV regularizers built on spatial graphs improve over grid-based SSTV [46]; graph TV combined with low-rank priors has also proven effective beyond denoising, e.g., in heterogeneous change detection [47]. The group behind KGLRSSBS first coupled adaptive-weight graph TV with low-rank recovery [36], scaled superpixel-based GSP restoration to large scenes with a distributed algorithm [37], then introduced the superpixel-body Kronecker product graph [38], and recently combined it with a Tucker decomposition in LRTDKGLR [39]; the strong product has appeared in the group’s work on time-varying graph-signal inpainting [41], though not as an HSI regularizer. Both KGLRSSBS and LRTDKGLR adopt the Kronecker product—which we show is edge deficient—whereas our work replaces it with a weighted product family that restores the pure spatial and spectral edges, couples the graph term with a global (matrix or Tucker, Section 3.8) low-rank prior, and quantifies the edge-type trade-off through an explicit ablation. Unlike generic product-graph learning [34,35], our contribution is the specific weighted-product-graph construction for HSI mixed-noise removal and its ADMM solver with thresholding steps and a sparse CG subproblem.

3. Method

Figure 1 gives an overview of the proposed method: a superpixel-adapted spatial graph and a band path graph are combined through the weighted product-graph family into the WSPGLR regularizer, which is coupled with a global low-rank plus sparse model and solved by ADMM.

3.1. Observation Model and Notation

A graph $\mathcal{G}=(\mathcal{V},\mathcal{E})$ has (weighted) adjacency $\mathit{A}$, degree $\mathit{D}=\mathrm{diag}\left(\mathit{A}\mathbf{1}\right)$ and combinatorial Laplacian $\mathit{L}=\mathit{D}-\mathit{A}$; its symmetric normalized form is ${\mathit{L}}^{\mathrm{sym}}=\mathit{I}-{\mathit{D}}^{-1/2}\mathit{A}{\mathit{D}}^{-1/2}$. An observed HSI $\mathcal{O}\in {\mathbb{R}}^{M\times N\times p}$ (p bands) with mixed noise is modelled as

$$\mathcal{O}=\mathcal{X}+\mathcal{S}+\mathcal{N},$$

(1)

where $\mathcal{X}$ is the clean image, $\mathcal{S}$ collects sparse noise (impulse, stripes, dead lines) and $\mathcal{N}$ is Gaussian noise. We write $\mathit{O}\in {\mathbb{R}}^{MN\times p}$ for the band-wise unfolding. In the optimization, the dense perturbation is not assigned a separate variable: the low-rank and graph penalties suppress it in the estimate $\mathit{X}$, whereas $\mathit{S}$ explicitly captures sparse outliers.

3.2. Superpixel Spatial Graph and Band Path Graph

The first principal component of $\mathcal{O}$ is over-segmented by SLIC [28] into superpixels (Figure 2). The spatial graph ${\mathcal{G}}_c$ has one node per pixel and a 4-neighbor edge between spatially adjacent pixels. Edges within a superpixel receive unit weight, while the sparse edges that cross a superpixel boundary are down-weighted by a factor $w_b$ ($w_b=0.2$ throughout; $w_b=0$ recovers a hard cut), which preserves object boundaries without introducing blocking artifacts at superpixel borders. If $z_i\in [0,1]$ denotes the normalized first-PC value, a spatial edge has weight $c_{ij}\exp [-{(z_i-z_j)}^2/{\sigma }_b^2]$, where $c_{ij}=1$ within a superpixel, $c_{ij}=w_b$ across a boundary, and ${\sigma }_b=0.15$. Thus, smooth regions couple more strongly. Under a superpixel-wise pixel ordering the adjacency ${\mathit{A}}_c\in {\mathbb{R}}^{MN\times MN}$ is therefore nearly block-diagonal, with only the down-weighted boundary edges coupling different superpixels. The band path graph ${\mathcal{G}}_p$ is a path graph over the p bands with adjacency ${\mathit{A}}_p\in {\mathbb{R}}^{p\times p}$, encoding spectral contiguity.

3.3. A Weighted Product-Graph Family

On the pixel–band lattice ${\mathcal{V}}_c\times {\mathcal{V}}_p$ there are two elementary edge groups: the pure edges (a pure-spatial term ${\mathit{I}}_p\otimes {\mathit{A}}_c$ that links neighboring pixels within a band, and a pure-spectral term ${\mathit{A}}_p\otimes {\mathit{I}}_{MN}$ that links a pixel across adjacent bands), and the joint edges ${\mathit{A}}_p\otimes {\mathit{A}}_c$ that link neighboring pixels across adjacent bands. We introduce a two-parameter weighted product graph

$${\mathit{A}}_{\alpha ,\beta }=\alpha \left({\mathit{A}}_p\otimes {\mathit{I}}_{MN}+{\mathit{I}}_p\otimes {\mathit{A}}_c\right)+\beta \left({\mathit{A}}_p\otimes {\mathit{A}}_c\right),$$

(2)

where $\alpha ,\beta \ge 0$ and the ordering ${\mathit{A}}_p\otimes {\mathit{A}}_c$ matches the column-major vectorization of an $MN\times p$ block. The first bracket collects the pure-spectral and pure-spatial edges, whereas the second term contains the joint spatial–spectral edges. This family contains the three canonical products as exact special cases (Figure 3):

$$\begin{array}{cc}\hfill (\alpha ,\beta )& =(0,1):\mathrm{Kronecker};(1,0):\mathrm{Cartesian};\hfill \\ \hfill (1,1)& :\mathrm{strong},\mathrm{with}{\mathit{A}}_{1,1}=({\mathit{A}}_p+{\mathit{I}}_p)\otimes ({\mathit{A}}_c+{\mathit{I}}_{MN})-\mathit{I}.\hfill \end{array}$$

(3)

The Kronecker product ($\alpha =0$) keeps only joint edges and discards the pure edges, which is exactly the edge deficiency of the graph used in [38]. The proposed WSPGLR fixes $\alpha =1$ (pure edges always present) and treats $\beta$ as a single interpretable weight on the joint edges; for $0\le \beta \le 1$, it therefore spans the Cartesian ($\beta =0$) and strong ($\beta =1$) products and interpolates between them. The regularizer uses the symmetric normalized Laplacian ${\mathit{L}}_{\alpha ,\beta }$ of (2), so that all graphs share the normalized spectral range $[0,2]$, avoiding an unnormalized scale confound, while differing in their edge sets and relative weights:

$${\mathcal{R}}_{\mathrm{WSPGLR}}\left(\mathit{x}\right)={\mathit{x}}^{\top }{\mathit{L}}_{1,\beta }\mathit{x}.$$

(4)

This nonnegative quadratic form is a graph-smoothness energy (a squared Laplacian seminorm), not a norm. Because ${\mathit{A}}_c$ contains only (weighted) 4-neighbor edges, ${\mathit{L}}_{1,\beta }$ is sparse; with a hard boundary cut ($w_b=0$) it would moreover decouple across superpixels.

3.4. Denoising Model

We combine a global low-rank prior on the clean image (which captures the whole-scene spectral subspace) with the WSPGLR smoothness prior (4) and a sparse noise term:

$$\underset{\mathit{X},\mathit{S}}{\min }{\parallel \mathit{X}\parallel }_{*}+{\lambda }_1{\mathcal{R}}_{\mathrm{WSPGLR}}\left(\mathit{X}\right)+{\lambda }_2{\parallel \mathit{S}\parallel }_1\mathrm{s}.\mathrm{t}.\mathit{O}=\mathit{X}+\mathit{S},\mathrm{rank}\left(\mathit{X}\right)\le r,$$

(5)

where ${\mathcal{R}}_{\mathrm{WSPGLR}}\left(\mathit{X}\right)=\mathrm{vec}{\left(\mathit{X}\right)}^{\top }{\mathit{L}}_{1,\beta }\mathrm{vec}\left(\mathit{X}\right)$. Splitting the nuclear norm from the graph term with an auxiliary variable $\mathit{F}=\mathit{X}$ gives

$$\underset{\mathit{X},\mathit{S},\mathit{F}}{\min }{\parallel \mathit{F}\parallel }_{*}+{\lambda }_1{\mathcal{R}}_{\mathrm{WSPGLR}}\left(\mathit{X}\right)+{\lambda }_2{\parallel \mathit{S}\parallel }_1\mathrm{s}.\mathrm{t}.\mathit{O}=\mathit{F}+\mathit{S},\mathit{X}=\mathit{F},\mathrm{rank}\left(\mathit{F}\right)\le r.$$

(6)

3.5. ADMM Solver

The augmented Lagrangian of (6), with multipliers Λ, Γ and penalty $\mu >0$, is

$$\begin{array}{cc}\hfill \mathcal{L}=& {\parallel \mathit{F}\parallel }_{*}+{\lambda }_1{\mathcal{R}}_{\mathrm{WSPGLR}}\left(\mathit{X}\right)+{\lambda }_2{\parallel \mathit{S}\parallel }_1+\langle \mathbf{\Lambda },\mathit{O}-\mathit{F}-\mathit{S}\rangle +\langle \mathbf{\Gamma },\mathit{X}-\mathit{F}\rangle \hfill \\ \hfill & +\frac{\mu }{2}\left({\parallel \mathit{O}-\mathit{F}-\mathit{S}\parallel }_F^2+{\parallel \mathit{X}-\mathit{F}\parallel }_F^2\right).\hfill \end{array}$$

(7)

ADMM minimizes the blocks in Gauss–Seidel order.

(1)

Low-rank $\mathit{F}$ (truncated singular-value thresholding):

$${\mathit{F}}^{k+1}={\mathcal{D}}_{1/\left(2\mu \right)}\left(\frac{1}{2}\left(\mathit{O}-{\mathit{S}}^k+{\mathit{X}}^k+\frac{{\mathbf{\Lambda }}^k+{\mathbf{\Gamma }}^k}{\mu }\right)\right),\mathrm{rank}\le r,$$

(8)

with ${\mathcal{D}}_{\tau }\left(\mathit{Z}\right)=\mathit{U}\mathrm{diag}\left(\max ({\sigma }_i-\tau ,0)\right){\mathbf{V}}^{\top }$.

(2)

Graph smoothing $\mathit{X}$ (one sparse linear system):

$$\left(2{\lambda }_1{\mathit{L}}_{1,\beta }+\mu \mathit{I}\right)\mathrm{vec}\left({\mathit{X}}^{k+1}\right)=\mathrm{vec}(\mu {\mathit{F}}^{k+1}-{\mathbf{\Gamma }}^k),$$

(9)

solved by conjugate gradients; the system is sparse (at most 15 non-zeros per row, Section 3.6) and costs one sparse solve per iteration. Only ${\mathit{L}}_{1,\beta }$ changes with $\beta$/graph type, so all variants share the same complexity.

(3)

Sparse $\mathit{S}$ (soft-thresholding):

$${\mathit{S}}^{k+1}={\mathcal{S}}_{{\lambda }_2/\mu }\left(\mathit{O}-{\mathit{F}}^{k+1}+{\mathbf{\Lambda }}^k/\mu \right).$$

(10)

(4)

Multipliers: ${\mathbf{\Lambda }}^{k+1}={\mathbf{\Lambda }}^k+\mu (\mathit{O}-{\mathit{F}}^{k+1}-{\mathit{S}}^{k+1})$ and ${\mathbf{\Gamma }}^{k+1}={\mathbf{\Gamma }}^k+\mu ({\mathit{X}}^{k+1}-{\mathit{F}}^{k+1})$, with $\mu \leftarrow \min (\rho \mu ,{\mu }_{\max })$. Iteration stops when ${\parallel \mathit{O}-\mathit{F}-\mathit{S}\parallel }_F/{\parallel \mathit{O}\parallel }_F\le {\epsilon }_1$ and ${\parallel \mathit{X}-\mathit{F}\parallel }_{\infty }\le {\epsilon }_2$, or when the iteration budget is reached; the clean HSI is $\widehat{\mathcal{X}}=\mathit{F}$.

Algorithm 1 summarizes the procedure.

Algorithm 1: WSPGLR for HSI mixed-noise removal

Input:  noisy $\mathit{O}$; rank r; ${\lambda }_1,{\lambda }_2$; balance $\beta$. PCA first component → SLIC superpixels → spatial graph ${\mathit{A}}_c$; band path graph ${\mathit{A}}_p$. Build the normalized weighted product-graph Laplacian ${\mathit{L}}_{1,\beta }$ from (2). Initialize $\mathit{F}=\mathit{X}=\mathit{S}=\mathbf{\Lambda }=\mathbf{\Gamma }=0$, $\mu ={10}^{-2}$. repeat: update $\mathit{F},\mathit{X},\mathit{S}$ by (8),(9),(10); update Λ, Γ, $\mu$; until the stopping criterion or iteration budget is reached. Output:  denoised HSI $\widehat{\mathcal{X}}=\mathit{F}$.

3.6. Computational Complexity

The per-iteration cost of Algorithm 1 is dominated by two operations. The low-rank update (8) is an economy-size SVD of an $MN\times p$ matrix, $\mathcal{O}\left(MN{p}^2\right)$ (or the truncated HOSVD update of Section 3.8, whose Gram matrices cost $\mathcal{O}\left(MNp(M+N+p)\right)$ but remain small in practice). The graph update (9) is a conjugate-gradient (CG) solve with the sparse matrix $2{\lambda }_1{\mathit{L}}_{1,\beta }+\mu \mathit{I}$: every node of the pixel–band lattice has at most 4 spatial, 2 spectral and 8 joint neighbors, so the system matrix has at most 15 non-zeros per row independently of the image size, and each CG iteration costs $\mathcal{O}\left(MNp\right)$. With a fixed CG tolerance the overall per-iteration cost is therefore $\mathcal{O}\left(MN{p}^2+K_{\mathrm{CG}}MNp\right)$ and the memory footprint of the Laplacian is at most $15MNp$ non-zeros. With a hard boundary cut ($w_b=0$), ${\mathit{A}}_c$ becomes block-diagonal across superpixels and the solve additionally parallelizes over superpixels; the default soft weighting ($w_b=0.2$) keeps the same per-row sparsity bound. Measured single-scene runtimes are reported in Section 4.3.

3.7. Optional Edge-Preserving Refinement

The graph term in (5) is a quadratic (Tikhonov) smoother; on piecewise-smooth scenes an additional total-variation prior can further suppress residual noise. We therefore optionally apply one edge-preserving TV step [10] to the reconstruction $\widehat{\mathcal{X}}$, with a weight $\eta$ selected by the validation protocol of Section 4.3. Crucially, this weight is scene-adaptive and increases with scene smoothness: the validation selects $\eta =0$ on the most detailed scene (WDC, all cases, whose results are therefore produced by the graph model alone), a small weight on Pavia ($\eta =0$ or $0.008$) and larger weights on the smooth Indian scene ($\eta$ up to $0.015$). The refinement is thus a scene-adaptive add-on and does not affect the ablation of Section 4.5, which is performed without it.

3.8. Modular Low-Rank Term: A Tensor Extension (WSPGLR-T)

The low-rank block of (6) can be replaced by a Tucker-rank constraint, with the corresponding change to the $\mathit{F}$-update. The weighted product-graph term and the remaining updates are unchanged. As an instance we define WSPGLR-T, which constrains $\mathit{F}$ (reshaped to $M\times N\times p$) to a Tucker rank $(r_1,r_2,r_3)$; the $\mathit{F}$-update becomes a truncated higher-order SVD approximation of the same target matrix as in (8). This replaces the nuclear-norm penalty and matrix-rank constraint with a Tucker-rank constraint. Truncated HOSVD is generally not the exact best approximation at the prescribed multilinear rank, so this variant uses an approximate low-rank update. This yields a direct, controlled comparison of matrix and Tucker low-rank blocks under the same weighted product graph (Section 4.7); the original LRTDTV [12] result is reported separately as same-noise context, not as an otherwise matched ablation.

4. Experiments

4.1. Datasets, Noise and Metrics

Simulated experiments use three cubes spanning two scene types: two detailed urban scenes—a $200\times 200\times 191$ region of Washington DC Mall (WDC, Purdue MultiSpec, https://engineering.purdue.edu/~biehl/MultiSpec/hyperspectral.html; accessed on 9 September 2026) and a $200\times 200\times 103$ region of Pavia University—and one smooth agricultural scene, the $145\times 145\times 224$ simulated Indian Pines cube (Pavia and Indian Pines both from the GIC hyperspectral scene collection, https://www.ehu.eus/ccwintco/index.php/Hyperspectral_Remote_Sensing_Scenes; accessed on 9 September 2026), all normalized to $[0,1]$. Four mixed-noise cases, all instances of the degradation model (1), follow the direct baseline [38] so that the main quantitative comparison (Section 4.4) uses the same noise protocol: Case 1 equal-variance Gaussian $\sigma =0.025$ + impulse $p=0.05$; Case 2 equal $\sigma =0.1$ + $p=0.2$; Case 3 band-varying $\sigma \in [0,0.2]$ + impulse $\in [0,0.2]$; Case 4 is Case 3 plus dead lines, which corrupt random columns (width 1–3 px, 3–10 columns per affected band) to zero in $\sim 40\%$ of bands, chosen independently of Case 3’s per-band severity draw. Cases 1–4 span the same range of severities used across the compared low-rank/graph literature, from Case 1 (mild) up to Cases 2–4, which are a deliberate stress test rather than typical operating conditions; Section 4.6 adds a lower-severity and a physically motivated signal-dependent regime to confirm the reported gains do not depend on this severity range. WDC settings are repeated over two noise realizations (mean ± std). Real experiments use the HYDICE Urban and GF-5 Baoqing scenes, with GF-5 Shanghai and AVIRIS Cuprite (JPL AVIRIS data portal, https://aviris.jpl.nasa.gov/data/index.html; accessed on 9 September 2026; a different sensor family) added in Section 4.9 as further real-scene validation. We report Mean PSNR (MPSNR), Mean SSIM (MSSIM), ERGAS and Spectral Angle Mapper (SAM); real data (no ground truth) are assessed visually and by the no-reference diagnostics of Section 4.9 (method noise, stripe jitter, structure leakage). In the tables, ↑ indicates that larger values are better and ↓ indicates that smaller values are better.

4.2. Implementation and Baselines

For the simulated benchmarks, SLIC uses compactness 0.08 and targets one segment per 56 pixels, with a minimum of 120 segments. WSPGLR processes all p bands jointly. The matrix rank is $r=5$ for WDC and Pavia and $r=8$ for Indian Pines. Unless stated, ${\lambda }_2=0.15$, $\beta =0.25$, boundary weight $w_b=0.2$ with bilateral modulation, symmetric normalized Laplacian, $\rho =1.5$, ${\mu }_{\max }={10}^6$; ${\lambda }_1$ and the refinement weight $\eta$ are selected per case by the supervised validation protocol of Section 4.3 and shared across all graph variants for fairness. We compare against three methods run from the authors’ original MATLAB code—LRTV [10], LRTDTV [12], and LLRGTV [13]—and three controlled baselines implemented in Python: a global RPCA control inspired by LRMR [4], a subspace-RPCA-TV control inspired by FastHyDe [15], and a matched Kronecker-graph control inspired by KGLRSSBS [38]. They are not claimed to reproduce the published LRMR patch grouping, the original FastHyDe eigen-image denoiser, or KGLRSSBS’s local superpixel-body and overlapping-band solver; implementation-accurate control names are therefore used in every numerical table and figure. The matched Kronecker control intentionally uses the same global-low-rank/sparse formulation and solver as WSPGLR, with only the product graph changed, so it isolates the proposed graph contribution; comparisons against the three original-code methods remain full-method comparisons.

Table 1. Measured single-scene runtime and peak memory on WDC Case 3 ($200\times 200\times 191$, 48-core Xeon 6248R, Intel Corporation, Santa Clara, CA, USA; NVIDIA RTX A6000, NVIDIA Corporation, Santa Clara, CA, USA). Python CPU timings (upper block) are directly comparable; HSDT and QRNN3D use warmed-up single-cube CUDA inference (five warm-up runs, 20 measured runs); S2TDM uses one full-cube warm-up and five measured runs because each inference contains ten diffusion steps over 11 overlapping spectral windows. All GPU timings synchronize before and after each run, include host–device transfers, and report peak allocated GPU memory; LRTV/LRTDTV/LLRGTV run the authors’ original MATLAB code under GNU Octave 5.2 and include interpreter overhead, so their runtimes are indicative only. PCC-GLR reports the mean and population standard deviation of its two WDC Case 3 runs under MATLAB R2021a. Memory was not measured for the MATLAB/Octave methods, since its accounting is not directly comparable with the Python and CUDA values.

Method	Runtime (s)	Peak Memory (MiB)	Implementation
Global RPCA	14	879	Python (ours)
Subspace-RPCA-TV	15	881	Python (ours)
Matched Kron-control	100	4305	Python (ours)
WSPGLR	123	6385	Python (ours)
HSDT-L-complex	$0.658\pm 0.013$	5000.8	PyTorch/CUDA
QRNN3D-complex	$0.413\pm 0.016$	4346.8	PyTorch/CUDA
S2TDM-complex (2025)	$13.235\pm 0.113$	454.8	PyTorch/CUDA
LRTV	133	Not measured	original MATLAB/Octave
LRTDTV	537	Not measured	original MATLAB/Octave
LLRGTV	4048	Not measured	original MATLAB/Octave
PCC-GLR (2026)	$50.261\pm 4.919$	Not measured	original MATLAB R2021a

lists the implementation used for every method. The comparison is deliberately training-free and model-based: deep and self-supervised denoisers [19,20,21,22,23] operate in a different regime—they require external training data or per-scene optimization on a GPU—whereas our contribution is a regularizer within the model-based family, so the comparison targets that family and, in particular, the matched Kronecker control. We nonetheless add five additional baselines on identical inputs and metrics. Four are learned methods evaluated outside their training domain with no retraining: HSDT [44], a 2023 spectral-attention transformer, run with its released hsdt_l_complex checkpoint (trained on 31-band ICVL data under a complex synthetic-noise protocol) in its flex attention mode, which replaces the checkpoint’s fixed 31-band linear projection with a band-count-agnostic dot-product attention and lets the same weights run unmodified on our 103–224-band cubes; and QRNN3D [21], a 2021 quasi-recurrent 3-D network run with its complex checkpoint (also 31-band ICVL training, but under a noise protocol—impulse, stripe and dead-line corruption combined with Gaussian noise—closer in spirit to our own Cases 1–4 than HSDT’s), whose fully convolutional, band-count-agnostic architecture requires no adaptation at all. The third is MP-HSIR [48], an ICCV 2025 universal HSI-restoration transformer, run with the authors’ remote-sensing checkpoint and complex-noise prompt. Because that released checkpoint has fixed 100-band input/output layers, we cover each full cube by consecutive 100-band windows with 50-band stride and average overlapping estimates; this explicit inference adaptation uses no target-scene training or parameter selection. The fourth is S2TDM [43], first published online in 2025 and assigned to a 2026 volume, and is a spatial–spectral transformer diffusion model. We use its released model_complex checkpoint and the paper’s 10-step sampling schedule; because the checkpoint is trained for 31-band ICVL cubes, each complete test cube is processed using 31-band windows with 16-band stride and overlap averaging, with no target-scene retraining or parameter selection. This adds a recent diffusion family under exactly the same input cubes, noise realizations, and four evaluation metrics. The fifth baseline is 2026 PCC-GLR [40], a model-driven denoiser that combines global and local Pearson spectral graphs with low-rank and sparse-noise terms. We run the released MATLAB code with the authors’ demo parameters unchanged (including its shallow FGLR initialization, local-window settings and BM3D eigen-image step), without test-ground-truth tuning.

Table 2. Comparison with five additional baselines—four deep networks evaluated outside their training domain (HSDT [44] (hsdt_l_complex checkpoint, flex attention mode, no retraining) and QRNN3D [21] (complex checkpoint, natively band-count-agnostic, no retraining), and ICCV 2025 MP-HSIR [48] (released 100-band remote-sensing checkpoint and complex-noise prompt; 100-band windows with 50-band stride, overlap averaged; no retraining), and S2TDM [43] (released 31-band complex-noise checkpoint; the published 10-step sampler; 31-band windows with 16-band stride, overlap averaged; no retraining)) and the model-driven 2026 PCC-GLR [40] (released MATLAB code and demo parameters, no test-ground-truth tuning)—on all three simulated datasets under the four mixed-noise cases. Every entry is the mean ± population standard deviation over three independently generated test realizations (seeds 0–2); parameters are fixed across these test seeds. Best in bold.

Dataset	Case	Method	MPSNR ↑	MSSIM ↑	ERGAS ↓	SAM ↓
WDC	1	HSDT	34.33 ± 0.00	0.9486 ± 0.0001	12.22 ± 0.00	6.01 ± 0.00
		QRNN3D	32.42 ± 0.01	0.9440 ± 0.0000	15.85 ± 0.02	7.43 ± 0.00
		MP-HSIR	30.88 ± 0.01	0.9180 ± 0.0002	25.16 ± 0.02	13.03 ± 0.01
		S2TDM (2025)	35.37 ± 0.01	0.9710 ± 0.0001	11.53 ± 0.01	6.49 ± 0.01
		PCC-GLR (2026)	37.46 ± 0.00	0.9781 ± 0.0000	9.95 ± 0.00	7.56 ± 0.00
		WSPGLR	41.73 ± 0.01	0.9901 ± 0.0000	5.80 ± 0.01	3.78 ± 0.00
	2	HSDT	29.70 ± 0.01	0.8666 ± 0.0004	20.50 ± 0.03	7.99 ± 0.01
		QRNN3D	29.47 ± 0.01	0.8830 ± 0.0002	22.07 ± 0.03	9.93 ± 0.01
		MP-HSIR	26.55 ± 0.01	0.8267 ± 0.0005	37.66 ± 0.06	17.78 ± 0.03
		S2TDM (2025)	27.91 ± 0.00	0.8565 ± 0.0003	27.32 ± 0.01	9.91 ± 0.01
		PCC-GLR (2026)	29.60 ± 0.02	0.8966 ± 0.0003	20.52 ± 0.05	12.27 ± 0.02
		WSPGLR	33.46 ± 0.00	0.9377 ± 0.0001	13.86 ± 0.02	7.27 ± 0.01
	3	HSDT	31.56 ± 0.29	0.9159 ± 0.0043	17.81 ± 0.52	7.48 ± 0.20
		QRNN3D	31.06 ± 0.18	0.9181 ± 0.0020	18.98 ± 0.35	8.81 ± 0.11
		MP-HSIR	27.48 ± 0.11	0.8608 ± 0.0038	36.02 ± 0.03	15.43 ± 0.21
		S2TDM (2025)	30.87 ± 0.38	0.9219 ± 0.0053	19.88 ± 0.87	8.66 ± 0.25
		PCC-GLR (2026)	29.54 ± 0.78	0.8979 ± 0.0139	21.12 ± 1.92	12.33 ± 0.76
		WSPGLR	35.68 ± 0.16	0.9614 ± 0.0010	11.44 ± 0.13	6.64 ± 0.35
	4	HSDT	31.46 ± 0.30	0.9136 ± 0.0048	17.81 ± 0.56	7.51 ± 0.20
		QRNN3D	31.07 ± 0.16	0.9176 ± 0.0021	18.77 ± 0.27	8.85 ± 0.13
		MP-HSIR	27.49 ± 0.06	0.8568 ± 0.0036	35.71 ± 0.08	15.59 ± 0.21
		S2TDM (2025)	30.66 ± 0.35	0.9156 ± 0.0056	19.85 ± 0.77	8.86 ± 0.25
		PCC-GLR (2026)	29.36 ± 0.76	0.8951 ± 0.0142	21.36 ± 1.83	12.62 ± 0.75
		WSPGLR	34.91 ± 0.15	0.9570 ± 0.0008	12.85 ± 0.37	7.20 ± 0.30
Pavia	1	HSDT	35.30 ± 0.00	0.9395 ± 0.0000	10.68 ± 0.01	4.07 ± 0.00
		QRNN3D	36.53 ± 0.00	0.9580 ± 0.0001	9.15 ± 0.01	3.96 ± 0.00
		MP-HSIR	31.64 ± 0.02	0.8784 ± 0.0002	29.52 ± 0.07	10.26 ± 0.02
		S2TDM (2025)	37.72 ± 0.02	0.9645 ± 0.0002	8.58 ± 0.03	3.83 ± 0.01
		PCC-GLR (2026)	39.34 ± 0.01	0.9726 ± 0.0001	9.68 ± 0.01	3.51 ± 0.00
		WSPGLR	41.20 ± 0.06	0.9759 ± 0.0003	6.06 ± 0.02	2.71 ± 0.01
	2	HSDT	31.35 ± 0.01	0.8699 ± 0.0003	16.07 ± 0.02	5.53 ± 0.00 *
		QRNN3D	31.31 ± 0.02	0.8879 ± 0.0002 *	16.43 ± 0.04	6.02 ± 0.01
		MP-HSIR	27.73 ± 0.02	0.8135 ± 0.0005	35.94 ± 0.04	13.15 ± 0.01
		S2TDM (2025)	30.04 ± 0.02	0.8684 ± 0.0003	19.88 ± 0.05	7.10 ± 0.01
		PCC-GLR (2026)	31.91 ± 0.03	0.8822 ± 0.0002	15.89 ± 0.04	6.02 ± 0.01
		WSPGLR	32.38 ± 0.12	0.8625 ± 0.0046	15.06 ± 0.20	7.04 ± 0.10
	3	HSDT	33.09 ± 0.34	0.9123 ± 0.0065	13.63 ± 0.35	5.04 ± 0.07 *
		QRNN3D	33.45 ± 0.35	0.9231 ± 0.0046 *	13.06 ± 0.42	5.32 ± 0.07
		MP-HSIR	28.38 ± 0.04	0.8311 ± 0.0015	37.43 ± 0.61	13.06 ± 0.14
		S2TDM (2025)	33.28 ± 0.48	0.9231 ± 0.0063	14.04 ± 0.51	5.64 ± 0.05
		PCC-GLR (2026)	32.96 ± 0.43	0.9083 ± 0.0075	14.54 ± 0.34	5.47 ± 0.13
		WSPGLR	35.25 ± 0.30	0.9161 ± 0.0034	13.04 ± 0.59	7.15 ± 0.22
	4	HSDT	33.03 ± 0.33	0.9106 ± 0.0066	13.69 ± 0.34	5.05 ± 0.06 *
		QRNN3D	33.46 ± 0.35	0.9223 ± 0.0049 *	12.97 ± 0.43 *	5.36 ± 0.09
		MP-HSIR	28.47 ± 0.02	0.8274 ± 0.0016	36.98 ± 0.44	13.16 ± 0.08
		S2TDM (2025)	32.99 ± 0.55	0.9167 ± 0.0066	14.49 ± 0.59	5.87 ± 0.12
		PCC-GLR (2026)	32.27 ± 0.36	0.9055 ± 0.0072	15.66 ± 0.23	6.19 ± 0.17
		WSPGLR	34.39 ± 0.35	0.9086 ± 0.0040	14.14 ± 0.28	7.67 ± 0.24
Indian	1	HSDT	28.03 ± 0.01	0.8657 ± 0.0002	11.35 ± 0.01	2.89 ± 0.00
		QRNN3D	30.47 ± 0.00	0.9077 ± 0.0003	7.37 ± 0.00	2.63 ± 0.00
		MP-HSIR	26.52 ± 0.01	0.8628 ± 0.0002	18.06 ± 0.01	6.89 ± 0.00
		S2TDM (2025)	33.58 ± 0.01	0.9736 ± 0.0001	5.77 ± 0.01	2.46 ± 0.00
		PCC-GLR (2026)	27.55 ± 0.01	0.9063 ± 0.0000	12.20 ± 0.02	5.07 ± 0.01
		WSPGLR	39.46 ± 0.01	0.9782 ± 0.0001	2.72 ± 0.00	0.94 ± 0.00
	2	HSDT	25.63 ± 0.00	0.8277 ± 0.0001	13.63 ± 0.01	4.00 ± 0.01
		QRNN3D	26.56 ± 0.01	0.7923 ± 0.0005	11.77 ± 0.01	3.86 ± 0.01
		MP-HSIR	24.02 ± 0.01	0.8144 ± 0.0001	22.15 ± 0.03	9.01 ± 0.02
		S2TDM (2025)	27.58 ± 0.01	0.9111 ± 0.0015 *	9.88 ± 0.02	3.91 ± 0.01
		PCC-GLR (2026)	26.81 ± 0.01	0.8201 ± 0.0009	12.52 ± 0.01	5.43 ± 0.00
		WSPGLR	31.84 ± 0.02	0.8078 ± 0.0009	5.95 ± 0.01	2.40 ± 0.00
	3	HSDT	27.04 ± 0.19	0.8490 ± 0.0030	12.50 ± 0.17	3.54 ± 0.11
		QRNN3D	29.12 ± 0.25	0.8627 ± 0.0045	9.15 ± 0.25	3.20 ± 0.07
		MP-HSIR	25.16 ± 0.20	0.8356 ± 0.0031	20.04 ± 0.39	7.96 ± 0.18
		S2TDM (2025)	30.82 ± 0.44	0.9481 ± 0.0050 *	7.52 ± 0.29	3.12 ± 0.10
		PCC-GLR (2026)	26.92 ± 0.06	0.8532 ± 0.0033	12.60 ± 0.08	5.45 ± 0.04
		WSPGLR	34.09 ± 0.18	0.8945 ± 0.0041	4.71 ± 0.05	1.73 ± 0.03
	4	HSDT	26.91 ± 0.20	0.8447 ± 0.0042	12.67 ± 0.25	3.58 ± 0.12
		QRNN3D	28.56 ± 0.21	0.8473 ± 0.0053	9.57 ± 0.26	3.40 ± 0.07
		MP-HSIR	24.57 ± 0.20	0.8212 ± 0.0025	20.37 ± 0.31	8.28 ± 0.15
		S2TDM (2025)	29.00 ± 0.41	0.9249 ± 0.0070 *	8.85 ± 0.34	3.51 ± 0.12
		PCC-GLR (2026)	25.41 ± 0.13	0.8500 ± 0.0043	14.05 ± 0.06	6.32 ± 0.03
		WSPGLR	32.96 ± 0.08	0.8805 ± 0.0064	5.48 ± 0.31	2.16 ± 0.19

* WSPGLR wins MPSNR in all 12 dataset × case combinations and ERGAS in 11/12 (QRNN3D is marginally lower on Pavia Case 4); on SAM and MSSIM, where WSPGLR is not best, HSDT, QRNN3D or S2TDM take the win, concentrated on Pavia Cases 2–4 and Indian Cases 2–4 (Section 5 discusses the SAM–MSSIM trade-off governed by β). Overall win counts across all 12 combinations: MPSNR WSPGLR 12/HSDT 0/QRNN3D 0/MP-HSIR 0/S2TDM 0/PCC-GLR 0; ERGAS WSPGLR 11/QRNN3D 1/HSDT 0/MP-HSIR 0/S2TDM 0/PCC-GLR 0; SAM WSPGLR 9/HSDT 3/QRNN3D 0/MP-HSIR 0/S2TDM 0/PCC-GLR 0; MSSIM WSPGLR 6/QRNN3D 3/S2TDM 3/HSDT 0/MP-HSIR 0/PCC-GLR 0.

reports the resulting comparison on all three simulated datasets and all four noise cases. All five additional baselines trail WSPGLR on MPSNR in every one of the 12 dataset × case combinations (WSPGLR also leads ERGAS in 11/12 and SAM in 9/12); the MPSNR margin over the strongest additional baseline ranges from 0.47 to 5.88 dB (3.17 dB on average). These are cross-domain checkpoint results: the differences reflect both mismatch between the released training distributions and our test scenes/noise mixtures and, where required, the disclosed fixed-band inference adaptations. They therefore characterize the robustness of released models under this protocol, not a general ranking of the architectures. Section 4.8 provides a complementary comparison in RND’s native evaluation domain. We also ablate the graph-product type.

4.3. Reproducibility and Runtime

Noise realizations and in-house stochastic steps use fixed random seeds (NumPy default_rng or explicit fixed seeds, as applicable). Table 2 uses seeds $\{0,1,2\}$ for every dataset–case pair;

Table 3. Quantitative comparison on the simulated Washington DC Mall dataset ($200\times 200\times 191$) under four mixed-noise cases (mean ± std over two noise realizations). Best in bold. “WSPGLR” is the pure graph model; WSPGLR+TV adds the TV refinement (weight $\eta$ selected by the validation protocol of Section 4.3). On this dataset $\eta =0$ was selected, so the two rows coincide.

Case	Method	MPSNR ↑	MSSIM ↑	ERGAS ↓	SAM ↓
1	Noisy	17.20 ± 0.00	0.4653 ± 0.0002	100.91 ± 0.05	35.01 ± 0.00
	Global RPCA	39.36 ± 0.00	0.9895 ± 0.0000	7.76 ± 0.00	3.69 ± 0.01
	LRTV [10]	39.24 ± 0.00	0.9833 ± 0.0000	7.02 ± 0.00	3.30 ± 0.02
	LRTDTV [12]	38.47 ± 0.00	0.9792 ± 0.0000	7.59 ± 0.00	3.45 ± 0.01
	Subspace-RPCA-TV	32.44 ± 0.00	0.9312 ± 0.0000	14.72 ± 0.00	4.86 ± 0.00
	LLRGTV [13]	33.09 ± 0.00	0.9525 ± 0.0000	16.09 ± 0.00	7.18 ± 0.01
	Matched Kron-control	41.68 ± 0.01	0.9901 ± 0.0000	5.81 ± 0.01	3.78 ± 0.01
	WSPGLR	41.74 ± 0.01	0.9901 ± 0.0000	5.80 ± 0.01	3.78 ± 0.01
	WSPGLR+TV	41.74 ± 0.01	0.9901 ± 0.0000	5.80 ± 0.01	3.78 ± 0.01
2	Noisy	10.94 ± 0.00	0.1274 ± 0.0000	206.37 ± 0.01	47.87 ± 0.01
	Global RPCA	31.48 ± 0.01	0.9407 ± 0.0000	17.51 ± 0.03	7.79 ± 0.01
	LRTV [10]	31.63 ± 0.01	0.9058 ± 0.0004	16.69 ± 0.02	6.23 ± 0.08
	LRTDTV [12]	31.53 ± 0.00	0.9015 ± 0.0002	16.74 ± 0.00	6.70 ± 0.01
	Subspace-RPCA-TV	29.94 ± 0.24	0.9104 ± 0.0083	20.17 ± 0.44	7.09 ± 0.05
	LLRGTV [13]	31.57 ± 0.00	0.9319 ± 0.0000	18.24 ± 0.01	8.07 ± 0.00
	Matched Kron-control	32.42 ± 0.01	0.9268 ± 0.0000	15.14 ± 0.01	7.07 ± 0.00
	WSPGLR	33.46 ± 0.00	0.9377 ± 0.0001	13.87 ± 0.01	7.26 ± 0.00
	WSPGLR+TV	33.46 ± 0.00	0.9377 ± 0.0001	13.87 ± 0.01	7.26 ± 0.00
3	Noisy	14.15 ± 0.32	0.2565 ± 0.0174	153.57 ± 0.05	43.32 ± 0.36
	Global RPCA	33.39 ± 0.10	0.9659 ± 0.0001	14.99 ± 0.10	6.46 ± 0.03
	LRTV [10]	33.08 ± 0.14	0.9248 ± 0.0023	15.06 ± 0.23	5.87 ± 0.09
	LRTDTV [12]	33.04 ± 0.15	0.9266 ± 0.0021	14.51 ± 0.23	6.12 ± 0.15
	Subspace-RPCA-TV	30.20 ± 0.07	0.9088 ± 0.0007	19.69 ± 0.13	6.84 ± 0.02
	LLRGTV [13]	32.29 ± 0.09	0.9434 ± 0.0007	17.08 ± 0.03	7.67 ± 0.00
	Matched Kron-control	34.34 ± 0.19	0.9530 ± 0.0004	12.58 ± 0.22	6.57 ± 0.45
	WSPGLR	35.61 ± 0.16	0.9607 ± 0.0005	11.47 ± 0.15	6.69 ± 0.42
	WSPGLR+TV	35.61 ± 0.16	0.9607 ± 0.0005	11.47 ± 0.15	6.69 ± 0.42
4	Noisy	14.04 ± 0.29	0.2496 ± 0.0164	152.79 ± 0.01	44.08 ± 0.30
	Global RPCA	32.55 ± 0.12	0.9608 ± 0.0004	17.16 ± 0.21	7.02 ± 0.06
	LRTV [10]	32.06 ± 0.11	0.9176 ± 0.0017	17.42 ± 0.23	7.56 ± 0.09
	LRTDTV [12]	32.47 ± 0.16	0.9197 ± 0.0024	15.69 ± 0.29	6.75 ± 0.02
	Subspace-RPCA-TV	29.71 ± 0.08	0.9042 ± 0.0006	21.40 ± 0.20	7.27 ± 0.05
	LLRGTV [13]	31.61 ± 0.15	0.9371 ± 0.0014	18.70 ± 0.16	8.20 ± 0.01
	Matched Kron-control	33.79 ± 0.12	0.9489 ± 0.0001	13.46 ± 0.04	6.53 ± 0.01
	WSPGLR	34.89 ± 0.18	0.9565 ± 0.0002	12.63 ± 0.25	7.05 ± 0.27
	WSPGLR+TV	34.89 ± 0.18	0.9565 ± 0.0002	12.63 ± 0.25	7.05 ± 0.27

,

Table 4. Quantitative comparison on the simulated Pavia University dataset ($200\times 200\times 103$, urban) under four mixed-noise cases (single realization). Best in bold. “WSPGLR” is the pure graph model; WSPGLR+TV adds the TV refinement (weight $\eta$ selected by the validation protocol of Section 4.3). On this dataset $\eta =0$ was selected for Case 1 (the two rows coincide) and $\eta =0.008$ for Cases 2–4.

Case	Method	MPSNR ↑	MSSIM ↑	ERGAS ↓	SAM ↓
1	Noisy	17.30	0.3765	85.58	31.50
	Global RPCA	39.25	0.9744	7.58	2.97
	LRTV [10]	40.78	0.9744	6.22	2.52
	LRTDTV [12]	40.14	0.9715	6.46	2.58
	Subspace-RPCA-TV	33.71	0.9101	12.63	3.96
	LLRGTV [13]	33.84	0.9379	15.50	5.41
	Matched Kron-control	39.81	0.9731	6.76	2.74
	WSPGLR	41.11	0.9764	6.10	2.72
	WSPGLR+TV	41.11	0.9764	6.10	2.72
2	Noisy	11.02	0.0861	175.36	47.10
	Global RPCA	29.16	0.8513	21.57	6.75
	LRTV [10]	33.23	0.9008	13.37	5.40
	LRTDTV [12]	33.10	0.8910	13.26	5.31
	Subspace-RPCA-TV	29.03	0.8784	21.88	5.81
	LLRGTV [13]	30.81	0.8817	18.53	6.55
	Matched Kron-control	31.78	0.8648	15.99	7.27
	WSPGLR	32.28	0.8588	15.19	6.91
	WSPGLR+TV	33.70	0.9065	12.74	5.46
3	Noisy	13.65	0.1643	134.31	42.91
	Global RPCA	30.88	0.9108	18.25	5.82
	LRTV [10]	34.32	0.9140	13.34	7.81
	LRTDTV [12]	34.39	0.9085	11.68	5.21
	Subspace-RPCA-TV	29.49	0.8762	20.68	5.88
	LLRGTV [13]	31.48	0.9057	17.10	6.14
	Matched Kron-control	33.76	0.9051	14.24	7.44
	WSPGLR	34.87	0.9116	13.11	7.41
	WSPGLR+TV	35.33	0.9267	12.21	6.56
4	Noisy	13.62	0.1604	133.89	43.76
	Global RPCA	29.85	0.9031	21.15	6.78
	LRTV [10]	33.33	0.9053	15.48	8.86
	LRTDTV [12]	33.57	0.8989	13.48	7.26
	Subspace-RPCA-TV	28.68	0.8694	23.28	6.68
	LLRGTV [13]	30.63	0.8989	18.67	6.99
	Matched Kron-control	33.03	0.9001	15.05	8.17
	WSPGLR	33.92	0.9029	13.85	7.92
	WSPGLR+TV	34.36	0.9194	13.05	7.05

and

Table 5. Quantitative comparison on the simulated Indian Pines dataset ($145\times 145\times 224$, agricultural/smooth) under four mixed-noise cases (single realization). Best in bold. “WSPGLR” is the pure graph model; WSPGLR+TV adds the TV refinement, for which the validation protocol of Section 4.3 selected $\eta >0$ on this smooth scene.

Case	Method	MPSNR ↑	MSSIM ↑	ERGAS ↓	SAM ↓
1	Noisy	17.88	0.4069	28.20	13.56
	Global RPCA	33.43	0.9706	5.24	1.90
	LRTV [10]	35.18	0.9852	4.54	1.53
	LRTDTV [12]	44.69	0.9973	1.58	0.52
	Subspace-RPCA-TV	35.51	0.9857	3.99	1.31
	LLRGTV [13]	25.59	0.9069	13.36	4.81
	Matched Kron-control	39.37	0.9777	2.74	0.93
	WSPGLR	39.46	0.9782	2.72	0.94
	WSPGLR+TV	40.31	0.9936	2.54	0.73
2	Noisy	11.54	0.1737	58.37	26.76
	Global RPCA	28.51	0.8241	8.80	3.46
	LRTV [10]	33.73	0.9702	5.18	1.98
	LRTDTV [12]	37.63	0.9819	3.21	1.16
	Subspace-RPCA-TV	29.50	0.9569	7.88	2.86
	LLRGTV [13]	25.44	0.8759	13.36	5.09
	Matched Kron-control	30.34	0.7689	6.78	2.32
	WSPGLR	31.83	0.8082	5.95	2.40
	WSPGLR+TV	35.71	0.9646	4.06	1.38
3	Noisy	13.87	0.2465	47.29	22.08
	Global RPCA	29.77	0.9176	7.70	2.97
	LRTV [10]	34.22	0.9795	4.86	1.82
	LRTDTV [12]	39.77	0.9914	2.54	0.88
	Subspace-RPCA-TV	30.59	0.9698	7.26	2.69
	LLRGTV [13]	25.51	0.8941	13.28	5.02
	Matched Kron-control	31.44	0.8406	5.98	1.72
	WSPGLR	33.91	0.8918	4.70	1.72
	WSPGLR+TV	35.97	0.9768	4.02	1.21
4	Noisy	12.99	0.2313	50.80	24.58
	Global RPCA	28.86	0.9105	8.63	3.29
	LRTV [10]	33.25	0.9767	5.46	2.18
	LRTDTV [12]	36.62	0.9816	4.33	1.87
	Subspace-RPCA-TV	29.59	0.9668	8.23	3.00
	LLRGTV [13]	25.10	0.8889	13.83	5.44
	Matched Kron-control	30.41	0.8105	6.64	1.96
	WSPGLR	32.91	0.8761	5.28	2.01
	WSPGLR+TV	34.89	0.9724	4.54	1.53

retain seeds $\{0,1\}$ for WDC and seed 0 elsewhere, as stated in their captions. Released third-party implementations retain their original initialization behavior; the corresponding inputs, outputs and run logs are archived with the seed lists to support reproducibility. ADMM uses ${\mu }_0={10}^{-2}$, $\rho =1.5$ and 16 iterations, with ${\epsilon }_1={\epsilon }_2={10}^{-4}$ for possible early stopping; the CG solver uses relative tolerance ${10}^{-4}$ with at most 60 inner iterations. Parameter selection on the simulated benchmark is supervised (it uses the simulated ground truth), with the criterion MPSNR + 100 × MSSIM—the $100\times$ factor is a fixed heuristic that puts MSSIM’s $[0,1]$ range on a scale comparable with MPSNR in dB, so neither metric is numerically negligible. We repeated the full-resolution, held-out two-stage selection with coefficients 50, 100 and 150. Across the 12 dataset–case combinations, all three coefficients select the same $({\lambda }_1,\eta )$ pair in 10 cases; only Pavia Case 1 (coefficient 50 selects $0.25/0$, while 100 and 150 select $0.4/0$) and Indian Pines Case 2 (coefficients 50 and 100 select $0.25/0.015$, while 150 selects $0.4/0.015$) differ. Thus, 100 is retained as the middle scale-balancing convention rather than claimed as a unique optimum. Specifically, ${\lambda }_1$ is selected from $\{0.12,0.25,0.4\}$ on a held-out noise realization drawn with seed 1000 and never reported; the test realizations use only seeds 0–2. The refinement weight $\eta$ is selected from $\{0,0.008,0.015,0.025\}$ on the same held-out seed-1000 realization for WDC, Pavia and Indian Pines; none of these validation realizations enters a reported test average. The selected values are then fixed, shared across all graph variants, and reused unchanged for every test realization. On the real scenes no ground truth is available and no per-scene tuning is performed: all parameters keep the defaults of Section 4.2 (${\lambda }_1=0.25$, no refinement). Experiments ran on a 48-core Intel Xeon Gold 6248R (3.0 GHz, 125 GB RAM) using Python 3.11.7 and NumPy 1.26.4 (baselines LRTV, LRTDTV and LLRGTV were run with the authors’ original MATLAB code under GNU Octave 5.2; PCC-GLR was run from its released code under MATLAB R2021a). As disclosed in the Acknowledgments, Codex CLI assisted code prototyping, data-analysis scripting and language editing; the authors reviewed the generated code, analyses and text.

Table 1 reports measured runtimes: restoring the pure edges costs only ∼23% more time than the matched Kronecker control (the Laplacian gains joint and pure entries but keeps its bounded per-row sparsity). The memory cost of the extra edges is proportionally larger than the time cost (∼48% more peak RSS than the matched Kron-control, 6.4 GB versus 4.3 GB on this $200\times 200\times 191$ cube): both graphs solve the same sparse linear system via conjugate gradients, but our implementation stores the Cartesian and joint blocks of ${\mathit{L}}_{1,\beta }$ as separate sparse factors before summing them, so the weighted product graph briefly holds more sparse-matrix data than the Kronecker graph’s single term; fused assembly could reduce this temporary storage. The Kronecker and WSPGLR CPU runtimes are directly comparable (both pure Python on the same hardware); the MATLAB/Octave figures are reported for context only and should not be read as a language-level efficiency claim, and the CUDA rows are likewise device-specific inference measurements rather than direct algorithmic comparisons with the CPU rows.

4.4. Quantitative Results

Table 3, Table 4 and Table 5 report WDC, Pavia and Indian Pines, and

Table 6. Average rank (1 = best; lower is better) over the three simulated datasets, per metric and overall. Best (lowest) in each column in bold.

Method	MPSNR	MSSIM	ERGAS	SAM	Overall
Global RPCA	6.17	4.08	6.42	5.00	5.42
LRTV	4.00	3.75	4.33	4.00	4.02
LRTDTV	3.33	4.17	2.58	1.83	2.98
Subspace-RPCA-TV	7.25	6.17	7.08	5.17	6.42
LLRGTV	6.92	5.83	7.25	7.00	6.75
Matched Kron-control	4.25	5.75	4.17	4.33	4.62
WSPGLR	2.54	4.21	2.54	5.04	3.58
WSPGLR+TV	1.54	2.04	1.62	3.62	2.21

summarizes the average rank of each method. Throughout, WSPGLR denotes the pure graph model—our main method—and WSPGLR+TV the optional post-processed variant of Section 3.7; on WDC the validation selected $\eta =0$ in every case, so the two rows coincide there, whereas small positive weights were selected on Pavia (Cases 2–4) and on Indian (Section 3.7)—every conclusion about the graph itself refers to the WSPGLR rows, which are reported for all datasets. On the detailed urban scenes (WDC, Pavia) WSPGLR attains the best MPSNR against the external methods and matched control in seven of eight settings, is non-leading in several MSSIM and SAM comparisons, and improves MPSNR and ERGAS over the matched Kronecker control in every case of every dataset (MSSIM in 11 of the 12 settings, the exception being Pavia Case 2, where it is 0.859 versus 0.865), with a graph-term-alone margin of up to 2.5 dB MPSNR (Indian Case 4, Table 5); the SAM results, however, reveal a spatial–spectral trade-off—the Kronecker graph, whose joint edges act as a strong spectral smoother, retains a small SAM advantage on WDC (Section 4.5). On the smooth agricultural scene (Indian) the tensor-TV method LRTDTV—whose global tensor factorization is well matched to piecewise-smooth data with pronounced low-rank structure—leads; there the TV refinement, which shares the same piecewise-smooth prior, recovers part of the gap (WSPGLR+TV ranks second and surpasses the global-RPCA and subspace-RPCA-TV controls, LLRGTV and the matched Kronecker control), but we attribute this gain to the post-processing, not to the graph. Thus, no single competitor is uniformly strong: LRTDTV excels on smooth scenes but trails WSPGLR by up to $3.3$ dB on detailed scenes. By the average rank of Table 6, the pure graph model attains the best MPSNR and ERGAS ranks among the competing baselines while uniformly improving the MPSNR of the superpixel/band-segmented framework it builds on, and the post-processed WSPGLR+TV additionally attains the best overall rank.

The average-rank summary in Table 6 separates the two contributions. The pure graph model WSPGLR attains the best MPSNR and ERGAS ranks among the competing baselines and improves the overall rank of its matched Kronecker control from 4.62 to 3.58; the optional post-processing then lifts WSPGLR+TV to the best overall rank (2.21), while LRTDTV remains strongest on SAM. This supports the intended interpretation: the graph itself delivers the spatial-reconstruction gains, the TV step is a scene-adaptive complement, and neither variant is uniformly dominant on every individual metric.

4.5. Ablation: Which Edges Matter

Figure 4 compares the restored images and error maps; Figure 5 reports band-wise quality; Figure 6 shows iteration behavior; and Figure 7 examines the joint-edge weight.

Table 7. Ablation over the graph-product type on the WDC dataset with the model, solver and hyperparameters fixed (mean ± std, two realizations); only the product graph is changed. Best in bold.

Case	Method	MPSNR ↑	MSSIM ↑	ERGAS ↓	SAM ↓
1	Matched Kron-control	41.68 ± 0.01	0.9901 ± 0.0000	5.81 ± 0.01	3.78 ± 0.01
	Cartesian	41.74 ± 0.02	0.9901 ± 0.0000	5.80 ± 0.02	3.78 ± 0.01
	Strong	41.73 ± 0.01	0.9901 ± 0.0000	5.80 ± 0.01	3.78 ± 0.01
	WSPGLR	41.74 ± 0.01	0.9901 ± 0.0000	5.80 ± 0.01	3.78 ± 0.01
2	Matched Kron-control	32.42 ± 0.01	0.9268 ± 0.0000	15.14 ± 0.01	7.07 ± 0.00
	Cartesian	33.56 ± 0.00	0.9382 ± 0.0001	13.81 ± 0.01	7.37 ± 0.00
	Strong	33.18 ± 0.00	0.9353 ± 0.0000	14.14 ± 0.00	7.15 ± 0.00
	WSPGLR	33.46 ± 0.00	0.9377 ± 0.0001	13.87 ± 0.01	7.26 ± 0.00
3	Matched Kron-control	34.34 ± 0.19	0.9530 ± 0.0004	12.58 ± 0.22	6.57 ± 0.45
	Cartesian	35.72 ± 0.13	0.9607 ± 0.0008	11.50 ± 0.11	6.80 ± 0.41
	Strong	35.40 ± 0.09	0.9596 ± 0.0003	11.40 ± 0.07	6.21 ± 0.05
	WSPGLR	35.61 ± 0.16	0.9607 ± 0.0005	11.47 ± 0.15	6.69 ± 0.42
4	Matched Kron-control	33.79 ± 0.12	0.9489 ± 0.0001	13.46 ± 0.04	6.53 ± 0.01
	Cartesian	34.95 ± 0.14	0.9569 ± 0.0000	12.72 ± 0.23	7.41 ± 0.11
	Strong	34.68 ± 0.14	0.9555 ± 0.0001	12.58 ± 0.07	6.61 ± 0.05
	WSPGLR	34.89 ± 0.18	0.9565 ± 0.0002	12.63 ± 0.25	7.05 ± 0.27

changes only the product graph while keeping the model, solver and hyperparameters fixed. The Kronecker graph (joint edges only) attains the worst PSNR/SSIM/ERGAS but, interestingly, the best SAM: its joint spatial–spectral edges act as a strong spectral smoother. Restoring the pure-spatial and pure-spectral edges (the Cartesian, Strong and WSPGLR graphs) lifts PSNR by up to $1.4$ dB on WDC and by up to $2.8$ dB on the other datasets and markedly improves SSIM/ERGAS, at a small SAM cost. Thus the product-graph type governs a spatial–spectral fidelity trade-off: pure edges favour spatial reconstruction, joint edges favour spectral fidelity. Within the strong-product family the effect of the balance weight $\beta$ on PSNR is mild (Figure 7); $\beta =0.25$ offers a favourable PSNR–SAM balance and is adopted as the default, retaining essentially all of the PSNR gain of the pure edges while tempering the SAM cost. Figure 7 sweeps $\beta$ on WDC only;

Table 8. Cross-dataset sensitivity of the joint-edge weight $\beta$ (Case 3, strong-product graph, no TV refinement; complements the WDC-only Figure 7). WDC entries are means over the same two seeds used in the main benchmark; Pavia and Indian entries use seed 0. Each dataset’s own MPSNR-best $\beta$ is in bold.

Dataset	$\mathit{\beta }=0$	0.1	0.25 (Default)	0.5	0.75	1
WDC (MPSNR/SAM)	35.72/6.80	35.68/6.75	35.61/6.69	35.49/6.65	35.48/6.23	35.40/6.21
Pavia (MPSNR/SAM)	34.81/7.39	34.87/7.42	34.87/7.41	34.82/7.38	34.76/7.36	34.69/7.34
Indian (MPSNR/SAM)	34.25/1.76	34.12/1.74	33.91/1.72	33.60/1.71	33.34/1.71	33.14/1.70

repeats the sweep on all three datasets (Case 3, fixed ${\lambda }_1$ per dataset, no TV refinement) to check whether the default needs per-dataset re-tuning. The trade-off strength itself is scene-dependent: on WDC, MPSNR falls only mildly ($35.72\to 35.40$ dB, $\beta =0\to 1$) while SAM improves ($6.80°\to 6.21°$), so a SAM-sensitive urban application could reasonably push $\beta$ higher; on Pavia, SAM is nearly insensitive to $\beta$ ($7.39°\to 7.34°$), so larger $\beta$ buys almost nothing there; on the smooth Indian scene, $\beta$ is not favourable at all—MPSNR falls monotonically and substantially ($34.25\to 33.14$ dB) for only a marginal SAM gain ($1.76°\to 1.70°$), because Indian’s gains come mainly from the TV refinement (Section 3.7) rather than from the joint-edge term. The fixed default $\beta =0.25$ is therefore a conservative, dataset-agnostic compromise—it never costs more than $0.34$ dB MPSNR on any of the three datasets relative to its own best-case $\beta$—rather than the optimum for any one scene type; Section 5 turns this into practical tuning guidance.

4.6. Realism Check: Moderate and Signal-Dependent Noise

Cases 1–4 (Section 4.1) follow the direct baseline’s protocol and intentionally span from mild (Case 1) to severe (Cases 2–4) additive noise, so that the main comparison uses the noise protocol of prior work; Cases 2–4 in particular are a stress test; their input MPSNR (10.9–17.9 dB across datasets, Table 3, Table 4 and Table 5) is substantially below the lower-severity regimes considered here. To test whether the WSPGLR-over-matched-control margin persists beyond this severity range and the purely additive model,

Table 9. Realism check on WDC: a moderate case and a signal-dependent Poisson–Gaussian case (Section 4.6), both milder than Cases 1–4. Entries are mean ± sample std over three independent test seeds (0–2). ${\lambda }_1=0.12$ was selected once on a separate validation realization (seed 1000) and then fixed for all test seeds and both graph variants. Best mean in bold.

Regime	Method	MPSNR ↑	MSSIM↑	ERGAS ↓	SAM ↓
Moderate ($21.06\pm 0.37$ dB)	Global RPCA	39.971 ± 0.049	0.99154 ± 0.00019	7.518 ± 0.016	3.523 ± 0.165
	Subspace-RPCA-TV	32.472 ± 0.045	0.93184 ± 0.00057	14.682 ± 0.069	4.821 ± 0.081
	Matched Kron-control	42.323 ± 0.031	0.99141 ± 0.00016	5.540 ± 0.013	3.587 ± 0.047
	WSPGLR	42.396 ± 0.025	0.99145 ± 0.00015	5.514 ± 0.005	3.579 ± 0.043
Signal-dep. ($23.21\pm 0.30$ dB)	Global RPCA	40.019 ± 0.045	0.99192 ± 0.00008	7.146 ± 0.026	3.275 ± 0.033
	Subspace-RPCA-TV	32.557 ± 0.023	0.93250 ± 0.00035	14.461 ± 0.038	4.639 ± 0.024
	Matched Kron-control	42.539 ± 0.022	0.99220 ± 0.00006	5.319 ± 0.011	3.394 ± 0.009
	WSPGLR	42.626 ± 0.023	0.99226 ± 0.00006	5.293 ± 0.014	3.384 ± 0.008

adds two regimes on WDC: a moderate case (band-varying $\sigma \in [0,0.05]$, impulse $\in [0,0.05]$) and a physically motivated signal-dependent case (band-varying Poisson shot noise on a peak photon count of 200–2000 plus a small Gaussian read floor, following the amplitude-dependent noise characterization of [3], with a light impulse component). Both push the input MPSNR up to $21.06\pm 0.37$ and $23.21\pm 0.30$ dB, respectively, well outside the stress-test range. The graph-only WSPGLR-over-matched-control margin shrinks sharply at this mild severity—from up to 2.5 dB under Cases 1–4 to $+0.072\pm 0.009$ and $+0.087\pm 0.003$ dB here. MPSNR is already above 42 dB for both methods. The gain is positive for each of the three independently generated test realizations in both regimes, but its small magnitude limits this result to a consistency check rather than a claim of practically large improvement under mild noise.

4.7. Tensor Extension: Modularity and Spectral-Fidelity Diagnostic

Table 10. Tensor extension as a modularity and spectral-fidelity diagnostic. WSPGLR-T replaces rank-constrained singular-value thresholding with a truncated HOSVD approximation while keeping the weighted product graph unchanged; both variants are run without the TV refinement and with matched parameters that are fixed across variants (hence the WSPGLR column differs slightly from the per-case-tuned values of Table 3, Table 4 and Table 5), and LRTDTV is run on identical noise instances for context. The comparison tests whether the low-rank block is replaceable and whether the tensor update improves spectral fidelity. Entries are MPSNR (dB)/SAM (deg); Δ columns give WSPGLR-T minus WSPGLR (negative ΔSAM is better).

Scene/Case	WSPGLR	WSPGLR-T	ΔMPSNR	ΔSAM	LRTDTV
WDC (urban), Case 3	35.45/7.11	35.01/6.55	−0.44	−0.56	32.89/6.27
Pavia (urban), Case 3	34.87/7.41	34.40/6.50	−0.47	−0.91	34.39/5.21
Indian (smooth), Case 1	39.41/0.93	39.55/0.87	+0.15	−0.06	44.69/0.52
Indian (smooth), Case 2	31.83/2.40	32.29/2.22	+0.46	−0.18	37.63/1.16
Indian (smooth), Case 3	34.18/1.86	34.50/1.72	+0.32	−0.14	39.77/0.88
Indian (smooth), Case 4	32.93/2.35	32.84/2.47	−0.09	+0.13	36.62/1.87

evaluates WSPGLR-T (Section 3.8), which swaps the matrix nuclear norm and rank constraint for a truncated HOSVD update while keeping the weighted product graph fixed; to isolate the low-rank term, neither variant uses the TV refinement here and all remaining parameters are matched. Three observations emerge. First, the effect of the Tucker prior is scene-dependent but modest: it yields a small PSNR/SSIM gain on the piecewise-smooth Indian cube and a small PSNR cost on the detailed urban scenes, which are not spatially low-rank. Second, the Tucker prior improves the spectral angle in five of the six settings—its spectral-mode truncation acts as an additional spectral regularizer—so WSPGLR-T is the preferable variant when spectral fidelity is the priority. Third, the original-code LRTDTV result provides same-noise context but is not an otherwise matched graph-versus-TV ablation; its stronger Indian result is nevertheless consistent with the fact that an ℓ₁ spatial–spectral TV is well matched to piecewise-constant scenes. In the synthetic Indian cube, $93\%$ of adjacent spatial pixel pairs have a band-averaged absolute clean-image difference below $0.5\%$ of the dynamic range, whereas the corresponding fractions are only $12\%$ (WDC) and $5\%$ (Pavia) for the urban scenes, where both of our variants surpass LRTDTV. This comparison delineates the observed applicability domain and demonstrates that the low-rank block is modular; it does not attribute the full between-method gap to a single regularizer or claim uniform superiority.

In summary, compared with matrix WSPGLR, WSPGLR-T improves SAM in five of the six tested settings at a nearly neutral mean MPSNR change ($-0.01$ dB on average); this confirms that the low-rank block is modular and that the Tucker variant is the appropriate choice when spectral fidelity is prioritized.

4.8. Real Paired-Noise Comparison Against a Domain-Trained Deep Denoiser (MEHSI)

Section 4.2’s HSDT comparison (Table 2) evaluates a deep denoiser outside its training domain. For a complementary native-domain comparison on genuine sensor noise, we compare against RND [45], a two-stage physical/implicit-noise-removal framework trained on MEHSI [45] (https://huggingface.co/datasets/YingkaiZhang/MEHSI; accessed on 9 September 2026), a paired real-noise HSI dataset (SOC710-VP camera, 34 bands, three controlled exposure ratios 1/20, 1/50, 1/100 of a fully-exposed reference). We use RND’s released checkpoint and its official test protocol unmodified (center $512\times 512$ crop; noisy input rescaled by the exposure ratio; output clamped to $[0,1]$) on all 30 official MEHSI test pairs (10 scenes × 3 exposure ratios); WSPGLR uses parameters fixed before testing (${\lambda }_1=0.25$, ${\lambda }_2=0.15$, $\beta =0.25$, $r=5$, no refinement or per-scene tuning), processes all 34 bands jointly, and uses the SLIC rule of Section 4.2.

Table 11. Real paired-noise comparison on MEHSI [45] (all 30 official test pairs: 10 scenes × 3 exposure ratios; mean over all pairs at each ratio). RND uses its released checkpoint and official test protocol unmodified (native MEHSI domain; checkpoint trained on the MEHSI training split); WSPGLR uses parameters fixed before testing. Best in bold.

Exposure Ratio	Method	MPSNR ↑	MSSIM ↑	SAM ↓	ERGAS ↓
1/20 (mildest)	Noisy input	28.55	0.677	13.44	26.75
	WSPGLR	30.87	0.881	6.23	19.83
	RND [45]	38.87	0.969	1.91	8.25
1/50	Noisy input	23.91	0.377	24.67	46.05
	WSPGLR	27.53	0.720	12.18	30.44
	RND [45]	37.15	0.959	2.21	9.91
1/100 (harshest)	Noisy input	19.69	0.190	38.02	72.73
	WSPGLR	22.52	0.507	21.66	51.39
	RND [45]	33.81	0.929	2.76	14.99
All 30 pairs (mean)	Noisy input	24.05	0.415	25.38	48.51
	WSPGLR	26.98	0.702	13.36	33.88
	RND [45]	36.61	0.953	2.29	11.05

reports the result. RND, trained on the MEHSI training split, wins all four metrics by a wide margin on every one of the 30 pairs (mean MPSNR $36.61$ vs. $26.98$ dB; SAM 2.29° vs. 13.36°). WSPGLR nevertheless improves all four metrics over the raw noisy input on every pair. RND used GPU inference whereas WSPGLR used CPU optimization, so the MEHSI wall-clock measurements are not used for an efficiency comparison; the controlled runtime analysis is reported in Table 1. Together with the cross-domain results in Table 2, this comparison delimits the evidence: WSPGLR is a training-free regularizer, not a claim of general superiority over domain-trained deep denoisers (Section 5).

4.9. Visual, Iteration and Parameter Analysis

Figure 4 compares reconstructions on WDC Case 3. Because better-performing methods are difficult to distinguish by eye in the restored false-color images, the figure adds band-averaged absolute-error maps on a common color scale: these expose the differences directly, with WSPGLR showing the smallest and least structured error. Figure 5 plots per-band PSNR/SSIM, Figure 6 the iteration behavior of MPSNR and the ADMM feasibility residual under the fixed budget. Figure 7 shows the $\beta$ sweep. Figure 8, Figure 9, Figure 10 and Figure 11 report real-data results on four scenes across three sensor families—HYDICE Urban, GF-5 Baoqing and Shanghai, and AVIRIS Cuprite. Figure 12 shows sensitivity to ${\lambda }_1$, ${\lambda }_2$ and r. Since no ground truth exists for the real scenes, we visualize the method noise [49] of each method—the difference between the original and the denoised image, which for an ideal denoiser should contain only noise—and summarize every scene by two no-reference quantities: the residual stripe jitter (mean absolute value of the mean profile taken across the stripe direction after subtracting its 5-tap moving average) and the structure leakage (correlation magnitude between the method noise and the high-pass detail of the corresponding result; pure noise is uncorrelated with scene detail, so this quantifies the classical requirement that the method noise “look like noise” [49]). A good method combines low jitter with low leakage. WSPGLR reduces the jitter from $10.0\times {10}^{-3}$ to $4.4\times {10}^{-3}$ on Baoqing and from $38.4\times {10}^{-3}$ to $29.2\times {10}^{-3}$ on Urban at near-minimal leakage (0.05–0.10); on the structure-rich Urban crop much of the remaining jitter is genuine one-pixel-scale scene detail rather than stripes, which is why the subspace-RPCA-TV control reaches a lower jitter ($11.8\times {10}^{-3}$) only at 2.7–6 times the leakage of WSPGLR (0.27–0.32 versus 0.05–0.10)—it removes signal together with the noise, as its method noise confirms. On the two added GF-5 scenes and on AVIRIS Cuprite, the same qualitative pattern holds: structure leakage is $0.053$–$0.101$ for WSPGLR and $0.059$–$0.113$ for the matched Kronecker control across all four scenes (WSPGLR lower on three of four; the matched control is marginally lower on Shanghai, $0.059$ versus $0.072$), while the subspace-RPCA-TV control’s leakage is $0.27$–$0.60$ on every single scene—consistently the highest of the compared methods regardless of sensor or location. Cuprite has comparatively little real striping to begin with (jitter $\approx 0.15$–$0.26\times {10}^{-3}$ for every method, an order of magnitude below the other three scenes), so there the leakage diagnostic, not stripe suppression, is the informative axis, and it reproduces the same ranking.

Figure 8. Real-data denoising on HYDICE Urban (band 139, horizontal stripes). The top row compares the original band with the subspace-RPCA-TV control, matched Kronecker control and WSPGLR at a common display size. The bottom row gives the three corresponding method-noise maps (original minus result) on a shared $\pm 2.5\sigma$ scale and a detrended row-mean profile. The numerical jitter/leakage diagnostic is reported in Table 12; the subspace control removes more profile variation but its structured method noise and higher leakage indicate signal loss.

Figure 8. Real-data denoising on HYDICE Urban (band 139, horizontal stripes). The top row compares the original band with the subspace-RPCA-TV control, matched Kronecker control and WSPGLR at a common display size. The bottom row gives the three corresponding method-noise maps (original minus result) on a shared $\pm 2.5\sigma$ scale and a detrended row-mean profile. The numerical jitter/leakage diagnostic is reported in Table 12; the subspace control removes more profile variation but its structured method noise and higher leakage indicate signal loss.

Figure 9. Real-data denoising on GF-5 Baoqing (band 96, vertical stripes). The top row shows the original and three full-size restorations; the bottom row shows their method noise and detrended column-mean profiles. Field boundaries visible in the subspace-RPCA-TV method noise agree with its higher structure-leakage value in Table 12.

Figure 9. Real-data denoising on GF-5 Baoqing (band 96, vertical stripes). The top row shows the original and three full-size restorations; the bottom row shows their method noise and detrended column-mean profiles. Field boundaries visible in the subspace-RPCA-TV method noise agree with its higher structure-leakage value in Table 12.

Figure 10. Real-data denoising on GF-5 Shanghai (band 96), using the same full-size restoration, method-noise and detrended-profile layout as Figure 8. The scene provides an independent within-sensor check of the Baoqing pattern.

Figure 10. Real-data denoising on GF-5 Shanghai (band 96), using the same full-size restoration, method-noise and detrended-profile layout as Figure 8. The scene provides an independent within-sensor check of the Baoqing pattern.

Figure 11. Real-data denoising on AVIRIS Cuprite (band index 96 of 188 good bands after standard water-absorption band removal), using the same layout as Figure 8. Because this band has little inherent striping (jitter $0.16$–$0.26\times {10}^{-3}$), structure leakage and the method-noise maps are more informative than profile suppression; the subspace control again removes substantial scene structure.

Figure 11. Real-data denoising on AVIRIS Cuprite (band index 96 of 188 good bands after standard water-absorption band removal), using the same layout as Figure 8. Because this band has little inherent striping (jitter $0.16$–$0.26\times {10}^{-3}$), structure leakage and the method-noise maps are more informative than profile suppression; the subspace control again removes substantial scene structure.

Figure 12. Parameter sensitivity of WSPGLR under the current WDC Case 3 protocol ($200\times 200\times 191$, 16 ADMM iterations). Points are means over seeds 0 and 1 and error bars are standard deviations; dotted lines mark the reported defaults. Each panel varies only the displayed parameter while holding the others at ${\lambda }_1=0.4$, ${\lambda }_2=0.15$ and $r=5$.

Figure 12. Parameter sensitivity of WSPGLR under the current WDC Case 3 protocol ($200\times 200\times 191$, 16 ADMM iterations). Points are means over seeds 0 and 1 and error bars are standard deviations; dotted lines mark the reported defaults. Each panel varies only the displayed parameter while holding the others at ${\lambda }_1=0.4$, ${\lambda }_2=0.15$ and $r=5$.

Table 12. No-reference diagnostics for the bands displayed in Figure 8, Figure 9, Figure 10 and Figure 11. Each method cell is residual stripe jitter ($\times {10}^{-3}$)/structure leakage; lower is better for both, but the two quantities must be interpreted jointly because aggressive smoothing can reduce jitter by removing scene structure. ND denotes not defined: the original image has no method-noise residual from which leakage could be computed.

Scene	Original	Global RPCA	Subspace-RPCA-TV	Matched Kron-Control	WSPGLR
Urban	38.379/ND	34.582/0.009	11.766/0.269	28.633/0.113	29.215/0.101
Baoqing	10.009/ND	3.770/0.103	2.343/0.315	4.627/0.061	4.421/0.053
Shanghai	4.007/ND	2.185/0.077	1.338/0.515	2.433/0.059	2.474/0.072
Cuprite	0.253/ND	0.253/0.010	0.159/0.598	0.261/0.090	0.256/0.071

Table 12. No-reference diagnostics for the bands displayed in Figure 8, Figure 9, Figure 10 and Figure 11. Each method cell is residual stripe jitter ($\times {10}^{-3}$)/structure leakage; lower is better for both, but the two quantities must be interpreted jointly because aggressive smoothing can reduce jitter by removing scene structure. ND denotes not defined: the original image has no method-noise residual from which leakage could be computed.

Scene	Original	Global RPCA	Subspace-RPCA-TV	Matched Kron-Control	WSPGLR
Urban	38.379/ND	34.582/0.009	11.766/0.269	28.633/0.113	29.215/0.101
Baoqing	10.009/ND	3.770/0.103	2.343/0.315	4.627/0.061	4.421/0.053
Shanghai	4.007/ND	2.185/0.077	1.338/0.515	2.433/0.059	2.474/0.072
Cuprite	0.253/ND	0.253/0.010	0.159/0.598	0.261/0.090	0.256/0.071

5. Discussion

The ablation clarifies a point left implicit in prior product-graph HSI models: adding pure-spatial and pure-spectral edges to the matched Kronecker control improves MPSNR in the tested settings, while the joint edges influence spectral fidelity. The results do not establish that the strong product is uniformly optimal—the Cartesian member ($\beta =0$) is occasionally the best on PSNR—but that the Kronecker graph is edge-deficient, that the tested pure-edge variants improve upon it on the spatial-reconstruction metrics, and that $\beta$ selects an operating point on the PSNR–SAM trade-off. The two-parameter product-graph family (2) exposes this cleanly: it contains the Kronecker, Cartesian and strong products as special cases (3), and within the pure-edge branch ($\alpha =1$) the single joint-edge weight $\beta$ lets the operating point trade a small amount of MPSNR for better spectral fidelity. Coupling the graph term with a global low-rank prior—rather than the per-body local low-rank of [38]—is effective on the two urban scenes, while the smooth-scene results expose its scene-dependent limitation. On the detailed urban scenes (WDC, Pavia) WSPGLR attains the best MPSNR against the external methods and matched control in seven of the eight settings (all eight with the TV step), outperforming even the tensor-TV method LRTDTV by up to $3.3$ dB (Table 3 and Table 4). On the smooth agricultural scene (Indian Pines) LRTDTV, whose global tensor factorization is well matched to piecewise-smooth data with pronounced low-rank structure, takes the lead; the post-processed WSPGLR+TV ranks second and surpasses the global-RPCA and subspace-RPCA-TV controls, LLRGTV and the matched Kronecker control, while the pure graph model is also non-leading on this scene. More generally, the strongest baselines are scene-dependent: WSPGLR attains the best MPSNR against the external methods and matched control in seven of eight urban settings, is non-leading on Indian Pines, and improves MPSNR over the matched Kronecker control in all 12 settings. Limitations include the non-leading performance on very smooth, low-rank scenes, the reliance on a single global rank, and the optional TV refinement whose weight, although selected by a fixed validation protocol rather than by hand, is an extra hyper-parameter. We also note that WDC results are averaged over two noise realizations, whereas the larger Pavia and Indian tables report a single realization; the WDC standard deviations (Table 3) are small, indicating stable behavior. Table 9 provides an additional three-seed check for the two milder WDC regimes and reports the uncertainty of the small WSPGLR–matched-control margins explicitly. The tensor extension of Section 4.7 already addresses the smooth-scene limitation in part and shows the low-rank term is modular. We also investigated a per-superpixel data-adaptive $\beta$ estimated from the pure/joint edge-energy ratio of a low-rank pilot; the resulting map is nearly constant across both scene types and does not improve on the fixed global $\beta$. This finding limits that particular energy-based rule; it does not exclude benefits from other spatially varying weights. Two further data-adaptive weightings were tested: correlation-based spectral edge weights are uninformative for the same reason (on a low-rank pilot, adjacent-band correlations are near one everywhere), while replacing the first-PC bilateral term by full-spectrum similarity acts as yet another spatial–spectral trade-off knob (on WDC it lowers MPSNR by 0.5 dB but improves SAM by 1.0°; on the smooth scene it is neutral) rather than a free improvement. Edge-adaptive weights, a locally-varying rank, and a broader comparison including non-local and deep denoisers are further natural extensions.

Practical Guidance and Limitations

Tuning $\beta$. Table 8 (Section 4.5) shows the PSNR–SAM trade-off controlled by $\beta$ is scene-dependent rather than a single universal curve. For detailed, spectrally busy scenes (WDC-like), the trade-off is real and worth exploring: $\beta$ up to $0.75$–1 trades about 0.3 dB MPSNR for a ∼0.6° SAM improvement, which is favourable when downstream spectral analysis (e.g., unmixing or classification) matters more than pixel fidelity. For scenes with flat spectral responses across neighboring pixels (Pavia-like), SAM is nearly insensitive to $\beta$, so the default is already close to optimal and increasing $\beta$ has little to offer. For smooth scenes with pronounced low-rank structure (Indian-like), $\beta$ is actively unfavorable—MPSNR degrades monotonically for marginal SAM gain—so we recommend $\beta \le 0.25$, or relying on the TV refinement (Section 3.7) rather than the graph term, for such scenes; this matches the paper’s own finding that Indian’s gains come mainly from the TV step. In the absence of scene-specific tuning, $\beta =0.25$ remains our recommended default: it is never far from the best achievable MPSNR on any of the three scene types tested (Table 8).

Noise-model scope. The main benchmark (Cases 1–4) uses additive, band-varying Gaussian and impulse noise, matching the direct baseline’s protocol; Section 4.6 finds small positive graph-control margins under a milder and a physically motivated signal-dependent (Poisson–Gaussian) regime. We have not evaluated spatially correlated noise (e.g., broader striping patterns than the column/line model of Section 4.1) or noise correlated across adjacent bands beyond the impulse and dead-line components already included.

Real-sensor scope. Section 4.9 now covers four no-reference real scenes across three sensor families (HYDICE Urban; GF-5 Baoqing and Shanghai; AVIRIS Cuprite), and Section 4.8 adds a fourth sensor family (SOC710-VP, via the paired real-noise MEHSI dataset) with genuine ground truth, which is broader than the original two-scene, two-sensor evaluation but still modest relative to the full diversity of operational HSI sensors (e.g., we have not tested ZY-1 02D because suitable raw scenes and reference protocols were not available for this study).

Deep-learning comparison scope. As detailed in Section 2, Section 4.2 and Section 4.8, we now include six additional baselines that characterize both directions of the generalization/specialization trade-off: HSDT, QRNN3D, ICCV 2025 MP-HSIR, S2TDM (online 2025; volume 2026) and model-driven 2026 PCC-GLR (Table 2), each evaluated on the same mixed-noise cubes (the four learned methods are outside their training domains). WSPGLR leads MPSNR in all 12 dataset × case combinations; S2TDM exceeds the other 2025 cross-domain baseline, MP-HSIR, in MPSNR in all 12 settings and wins MSSIM on Indian Cases 2–4, so the comparison also records where its learned prior is advantageous. RND (Table 11), evaluated in its native MEHSI domain on real paired camera noise (MEHSI), outperforms WSPGLR by a large margin while WSPGLR still provides a smaller, consistent improvement over the noisy input. The cross-domain and native-domain results define the evaluation scope of this study and motivate the training-free, no-external-data regime it targets. The controlled 12-case matrix now includes two independently released 2025 same-task methods from distinct learned families (multi-prompt transformer and transformer–diffusion) and the 2026 model-driven PCC-GLR, while the 2026 RND experiment provides the complementary native-domain result. It does not exhaust every 2025–2026 architecture or replace a future benchmark in which all networks are retrained for every sensor and noise model; that broader native-domain comparison remains outside the present study. The added diffusion baseline is a pretrained model; self-supervised diffusion and recent non-local tensor methods have not been evaluated separately.

6. Conclusions

We introduced WSPGLR, a Weighted Strong Product Graph Laplacian Regularizer, that restores the pure spatial–spectral edges omitted by the Kronecker product graph of prior superpixel/band-segmented HSI denoisers, and solved the resulting low-rank plus sparse model with an ADMM combining thresholding steps with a sparse CG solve. Across three simulated scenes, four no-reference real HSIs spanning three sensor families, and 30 paired MEHSI images from a fourth sensor family, WSPGLR consistently improves MPSNR and ERGAS over the matched Kronecker control in every simulated case (and MSSIM in 11 of 12 settings), while the SAM results expose a spatial–spectral fidelity trade-off governed by the joint-edge weight $\beta$; by average rank the pure graph model attains the best MPSNR and ERGAS ranks, and with the optional scene-adaptive TV post-processing the best overall rank, across scene types. An ablation isolates the source of the improvement in the restored pure spatial–spectral edges. A cross-dataset sweep of the joint-edge weight finds scene-dependent behavior; the small positive margins under milder and signal-dependent noise and the real-scene tests broaden the evaluation beyond the main stress-test protocol (Section 4.5, Section 4.6, Section 4.7, Section 4.8, Section 4.9 and Section 5). Six additional baselines broaden the comparison: HSDT, QRNN3D, ICCV 2025 MP-HSIR and S2TDM (online 2025; volume 2026) are run outside their training domain, and 2026 PCC-GLR is run from its released model-driven implementation, on the same 12 mixed-noise settings, where WSPGLR leads MPSNR throughout while S2TDM wins MSSIM on three Indian settings (Table 2); conversely, on real paired camera noise in its native MEHSI domain, RND outperforms WSPGLR by a wide margin, though WSPGLR still improves consistently over the noisy input (Table 11)—together illustrating the generalization/specialization trade-off that motivates a training-free regularizer. Future work will pursue adaptive Tucker ranks, adaptive edge weighting, per-scene rank, and a broader native-domain benchmark in which recent deep priors are retrained for each sensor and noise model.