Transmission-Aware Hybrid Image Deblurring Using Non-Local Means and Transformer Network with Edge-Preserving Improved Iterative Back Projection Cyber-Enhanced Refinement

Deblurring is a persistent problem in computational photography and computer vision areas, with huge implications for medical imaging, autonomous driving, commercial surveillance, and consumer photography applications. Blur degradation often results from camera motion, inadequate focus, or potentially environmental interference. Blur degradation results in lost high frequency details, smeared edges [1], and loss of perceptual clarity, ultimately complicating further vision tasks, including object recognition or describing a scene. Traditional deblurring methods were based on inverse filters, Wiener deconvolution, and relaxation and variational approaches, typically with a simplistic blur kernel or no defined kernel, and were not effective in many situations with remnant noise and blurry frames. Additionally, Non-Local Means (NLM) algorithms [2], which exploit self-similarity to suppress noise, do perform well but suffer somewhat from the problem of blurring when the blur is spatially variant. In comparison, research with deep learning methods, specifically, Deep Convolutional Neural Networks (DCNNs) [3-5] have produced promising results establishing a complicated mapping of blur to sharpness, but may present textures that are not representative or have no structure due to being classification techniques. Iterative Back Projection (IBP) methods don't have a theoretical limitation on ensuring consistency and could result in edges going out of alignment. To reinforce these perspectives, we present a hybrid framework to develop a combined NLM denoising classifier and improve processing on a DCNN. The NLM module first preprocesses the input by reducing noise while retaining edges, and acts as a regularizer for the upcoming steps. Next, the DCNN, trained with the proposed Edge-Aware Loss that has spatial gradient penalties, presumably favors high frequency reconstruction and edge fidelity, and works around the major challenge of texture loss from data-driven methods.

The Improved Iterative Back Projection (IIBP) module then minimizes the reconstruction error against a forward model of blur with the Convolutional Neural Network (CNN) output, while Cubic B-Spline with gradient interpolation provides both sub-pixel accuracy and a smooth transition between frames. The Edge-Aware Loss also adds gradient-based nudges to the optimization target of the CNN, enforcing geometrical consistency and alleviating blur-artifact trade-offs. This holistic approach not only leverages the strengths of each component but also mitigates their individual weaknesses: NLM’s dependency on patch similarity, CNN’s tendency toward overfitting, and IBP’s sensitivity to initialization. Experimental validation on benchmarks (e.g., GoPro, Köhler) demonstrates superior performance in both quantitative metrics (PSNR, SSIM) and perceptual evaluations, particularly in texture-rich regions and edge-dense scenarios where existing methods falter. The key novel contributions of this work include:

• A hybrid NLM-DCNN-IIBP pipeline that hierarchically addresses noise, blur, and reconstruction errors;
• An Edge-Aware Loss Function that explicitly optimizes for gradient coherence and edge preservation;
• Cubic B-Spline-enhanced IIBP for sub-pixel-accurate deblurring; and a modular framework adaptable to various blur types (motion, defocus) without retraining.

By unifying classical priors, deep learning, and iterative refinement, this method advances the state of the art in robust, high-fidelity deblurring, with direct applications in medical diagnostics, satellite imaging, and real-time video enhancement.

1.1 Problem identified

Current image deblurring techniques face three fundamental limitations:

• Traditional NLM methods effectively reduce noise but fail to address blur removal, often preserving artifacts in smooth regions;
• DCNN-based approaches generate plausible textures but frequently produce structurally inconsistent results due to their reliance on pixel-level loss functions;
• Conventional iterative back projection (IBP) methods suffer from convergence instability and edge misalignment, particularly with complex blur patterns.

These limitations collectively result in restored images with residual blur, artificial textures, and geometric distortions, especially in edge-dense and texture-rich regions where precise reconstruction is most critical for applications like medical imaging and surveillance.

1.2 Research gaps filled

The proposed work bridges these gaps through three key innovations:

• A hybrid NLM-CNN architecture that combines NLM's noise-aware preprocessing with CNN's blur pattern learning capability;
• An edge-aware loss function that explicitly preserves geometric structures during CNN training;
• An improved IBP algorithm enhanced with cubic B-spline interpolation for stable, sub-pixel accurate refinement.

This integrated approach uniquely addresses the noise-blindness of pure CNNs, the blur-removal limitation of NLM, and the convergence issues of traditional IBP. The resulting framework demonstrates superior performance in maintaining edge fidelity while suppressing artifacts, as validated through both quantitative metrics and perceptual evaluations.

The Hybrid Deblurring Architecture is a multi-stage image restoration framework, as in Figure 1; it is designed to effectively remove blur from degraded images by combining the strengths of three distinct techniques: NLM, DCNNs, and IIBP. Each component addresses a specific aspect of the deblurring challenge, resulting in a more robust and accurate reconstruction. The process begins with NLM denoising, which leverages the self-similarity of image patches across the entire image. This step reduces noise and preserves important structural details without requiring prior knowledge of the blur kernel. The cleaned image produced by NLM serves as a stable input for the next stage [27, 28].

Next, a DCNN is employed to recover high-frequency textures and fine details lost due to blur. The network is trained on blurred-sharp image pairs and uses deep hierarchical features to infer a deblurred version of the input. DCNN excels at learning complex blur patterns and restoring sharp content, but it may introduce artifacts or overfitting in certain cases. To correct these imperfections, IIBP is applied as a final refinement step. This method incorporates a forward blur model to iteratively compare the blurred estimate of the current image with the actual observed blur, and back-projects the difference to improve accuracy. Mathematically, it uses the residual error between the estimated and observed blur to adjust the output image toward physical realism.

By sequentially combining NLM, DCNN, and IIBP, the hybrid architecture benefits from the noise suppression of NLM, the feature learning of DCNN, and the model-based correction of IIBP. This integration results in a comprehensive deblurring system that handles diverse blur types while preserving structural integrity and visual fidelity.

tu_pian_1.png

(a)

tu_pian_2.png

(b)

Figure 1. Generic Structures of (a) overall taxonomy, (b) proposed deblurring module

3.1 Conceptual flow of the combined approach

The hybrid deblurring architecture integrates the strengths of three complementary image restoration techniques—NLM, DCNN, and IIBP—into a unified pipeline. The conceptual flow is structured in a three-stage sequential model, ensuring both global structure and fine-grained details are preserved and enhanced.

3.1.1 Stage 1: Initial Denoising via Non-Local Means

The input blurry image (x) is first passed through an NLM filter to suppress high-frequency noise while maintaining edge integrity. NLM leverages the self-similarity of natural images.

The output of this step is:

$\begin{aligned} & I_{N L M}(x) =\frac{1}{C(x)} \sum_{y \in \Omega} \exp \left(-\frac{\left\|B\left(N_x\right)-B\left(N_y\right)\right\| 2}{h^2}\right) B(y)\end{aligned}$           (1)

• C(x) is a normalizing constant;
• h controls the decay of the exponential function.

This step smooths noise while keeping fine texture regions intact, producing a cleaner image I_NLM.

3.1.2 Stage 2: Feature Restoration via Deep Convolutional Neural Network

The NLM output is then fed into a DCNN, trained on paired blurred-sharp image datasets. The DCNN aims to reconstruct high-frequency details lost during blur.

Given:

$I_{D C N N}=F \theta\left(I_{N L M}\right)$          (2)

where,

• Fθ is the DCNN parameterized by θ;
• The network optimizes a loss function, often:

$\mathcal{L}=\left|\left|I_{D C N N}-I_{G T}\right|\right| 2+\lambda| | \nabla I_{D C N N}-\nabla T_{G T}| |$           (3)

This loss combines pixel fidelity and edge consistency.

3.1.3 Stage 3: Refinement Using Iterative Inverse Back Projection

Finally, Iterative Inverse Back Projection is applied to fine-tune and correct residual errors between the reconstructed image and the observed blur. This technique uses a simulated degradation model H to back-project the residual error:

$e^{(t)}=B-H * I^{(t)}$          (4)

After several iterations of IIBP:

$I_{\text {Final }}=I^{(T)}$          (5)

This results in a sharper image, retaining both global consistency and localized details.

3.2 Deep Convolutional Neural Network: Deep learning for high-frequency recovery

DCNNs excel at learning spatial features that correspond to motion blur and other degradation patterns. Unlike classical filters, DCNNs:

• Learn hierarchical representations;
• Can generalize across varying blur types;
• Can incorporate attention mechanisms and residual learning for more accurate deblurring.

However, DCNNs may hallucinate textures or overfit training priors. Hence, relying solely on DCNNs risks loss of natural image structure.

3.2.1 Iterative Inverse Back Projection: Physics-based refinement

IIBP incorporates the physical blur model, acting as a feedback mechanism to enforce consistency between the deblurred image and the observed blur. It prevents overfitting to the training data and corrects:

• Artefacts introduced by CNN hallucinations;
• Minor spatial misalignments are computed with,

$I^{(t+1)}=I^{(t)}+\propto H^T\left(B-H I^{(t)}\right)$            (6)

This approach assumes a known or estimated blur kernel H, which can be obtained via edge-based or neural estimation methods.

3.2.2 Noise suppression via Non-Local Means

NLM is a powerful denoising technique that exploits the redundancy and self-similarity present in natural images. Unlike traditional filters that consider only local neighborhoods, NLM computes the denoised value of a pixel by averaging all pixels in the image, weighted by the similarity of their surrounding patches.

For a noisy image B(x), the NLM estimate at pixel x is given by:

$I_{N L M}(x)=\frac{1}{c(x)} \sum_{y \in \Omega} w(x, y) B(y)$         (7)

• w(x,y) is the similarity-based weight;
• h is the smoothing parameter;
• C(x) is a normalization constant ensuring weights sum to 1.

By averaging similar patches with no regard to spatial distance, NLM can attenuate random noise while still preserving edges and textures. This characteristic makes NLM an ideal solution for preprocessing blurred images, prior to higher-order restoration steps (e.g., convolutional networks or non-blind deblurring), and can put important image structures in place for the later deblurring steps.

3.3 Principle of non-local similarity

The principle of non-local similarity is at the heart of the NLM algorithm. The basic premise is that in most natural images, many small patches of pixels appear several times, not just in a local context but also far away. This repetition enables NLM to be an effective denoising algorithm, since the average intensity of a given pixel will be effective if taken from patches that are close together, even without much locality in pixel location (i.e., across an entire image). Unlike NLM, traditional filters (such as Gaussian or median filters) condition denoised pixel observations solely on the neighborhood of a local patch. Hence, given a pixel x, its value is restored through the computation of a weighted average of all other direct neighbouring pixels, which, apart from the local neighbourhood, could even be several pixels away, y, computed in terms of the similarity between patches in the images around pixel x and its current observation, with an average over all other pixels. The similarity weight is defined as:

$w(x, y)=\exp \left(-\frac{\left|\left|B\left(N_x\right)-B\left(N_y\right)\right|\right| 2}{h^2}\right)$          (8)

where, h is a filtering parameter that controls the exponential decay. This means that local structures that are similar to a pixel will contribute more to the output image pixel, although they may be further away from x. This non-local similarity is what allows the non-local filter to maintain textures, edges, and patterns while removing random noise. This method can be particularly effective in images that contain repeated structures, such as textures, patterns, or images of natural scenes.

3.4 Non-Local Means for structural protection and denoising

NLM is frequently applied in structural protection projects and denoising images explicitly when it is important to maintain important details. Common examples are medical imaging, satellite photos, and restoration of images of natural scenes. It is effective because it distinguishes noise from image features by comparing patches, which is less error-prone for identifying localized structures as opposed to comparing pixels in the image.

The assumption is that when one pixel is corrupted by noise, there are other noise-free patches in the image that have the same structure. By using redundancy of self-similar patches, NLM averages the intensity of the 'self-similar' patches to cancel out the noise while maintaining the actual signal. This is superior to local filters, where boundary details will often be blurred out in the smoothing process. The global filtering approach provided by NLM retains repeated patterns, and boundaries can be protected while suffering minimal distortion.

3.4.1 Parameters and patch selection in Non-Local Means

Three parameters are pivotal to the performance of the NLM algorithm: patch size, search window size, and the filtering parameter, ℎ. Properly tuning these parameters is critical to ensure adequate noise removal while retaining the amount of structure as possible.

Patch size (P): The patch size is the size of a square area N_x that is centered about each pixel. Larger patches will utilize a larger environmental window when determining similarity, which means that NLM is more resilient to noise. However, patch size should not be too large, lest small details are lost. Generally, patches are between 3 × 3 and 9 × 9 pixels.

Search window size (Ω): The search window size indicates how far away from the pixel the search algorithm will look for identified clusters of similar patches. Generally, the larger the search window size, the greater the likelihood of finding similar patches or similarity structures; however, from a computational complexity standpoint, a larger search window size adds additional computational needs. Common search window sizes used are 21 × 21 or 31 × 31 windows.

Filtering parameter (ℎ): The filtering parameter regulates the decay of the exponential similarity function. There may need to be a trade-off, since the smaller ℎ is, the more sensitive the algorithm will be to different patches while retaining structure such as edges. Thus, greater ℎ values make denoising effective at the cost of edge preservation and could oversmooth details. Efficient implementations would use pre-computed integral images or fast Fourier transforms (FFTs) to speed up this step. One of the great strengths of NLM is the ability to manipulate these parameters, making it easy to offer effective smoothing based on different noises and types of images.

3.4.2 Deep convolutional neural network for deblurring

DCNNs have become very useful for image deblurring because they can learn complicated relationships between the blurred image and the sharp image. DCNN deep learning methods are fundamentally different from previous works that have tried to use distorted images to solve deblurring problems by undoing models using inversions of the blur kernel, or assuming specific priors are known. DCNN methods use image data to learn hierarchical features to recognize blurred and sharp images. This makes them a natural fit for learning arbitrary types of blur structures.

In many deblurring DCNN models, a training set shows pairs of blurred and sharp images. Most architectures can support multiple turrets, convolutional layers, skip connections, max-pooling, and sometimes other supplemental methods like attention models to focus on the reconstruction task's important structures in the image. The theoretical goal will have the network be able to predict a sharp version of the input image by minimizing a loss function (loss function) (i.e., Mean Squared Error (MSE) or perceptual loss):

$\mathcal{L}_{\text {MSE }}=\left\|I_{\text {DCNN }}-I_{\text {GT }}\right\| 2$          (9)

DCNNs perform well in recovering high-frequency details and textures due to motion or defocus blur; however, if not properly regularized, they can distort the model learning of artifacts or overfit their training data. Thus, they are frequently used in hybrid approaches with traditional approaches (e.g., NLM; IIBP) in order to obtain perceptual visual quality as well as physical accuracy in de-blurring components.

3.4.3 CNN model design and layer configuration

Typically, a convolutional neural network for image de-blurring consists of multiple layers set up to progressively extract, process, and reconstruct image features. The design begins with shallow convolutional layers to obtain low-level edges and textures, then employs deeper layers to learn even more abstract, complex, and higher order features related to the original blur patterns.

• A common configuration is outlined next: Input Layer: Receives the preprocessed image (e.g., NLM output);
• Multiple Convolutional Layers: Each with small kernels (3 × 3 or 5 × 5), ReLU activation, and batch normalization for stable learning;
• Residual or Dense Blocks: Help mitigate vanishing gradients and allow efficient learning of residual blur details.

To enhance global feature modeling, Transformer self-attention blocks are integrated within the deeper encoder layers of the DCNN architecture. These Transformer modules capture long-range spatial dependencies and contextual blur information that conventional convolutional operations may fail to model effectively. Multi-head self-attention is employed after intermediate convolutional feature extraction stages, enabling improved representation of non-uniform motion blur and complex texture degradation. The hybrid CNN–Transformer configuration combines local feature extraction with global contextual learning for enhanced restoration accuracy.

Skip connections (as in U-Net or ResNet) are often used to preserve fine details. The network is trained end-to-end using a loss function such as MSE, SSIM, or perceptual loss to optimize visual quality and fidelity.

3.4.4 Feature learning for motion blur and complex distortions

CNNs are particularly effective in learning to correct motion blur and complex distortions because of their hierarchical feature extraction capabilities. During training, the network is exposed to pairs of blurred and sharp images, enabling it to learn blur-specific features such as streaks, directionality, and edge displacement.

Shallow layers capture local patterns like edges and noise, while deeper layers encode global structures, including motion trajectories and repetitive blur artifacts. The receptive field expands with depth, allowing the model to contextualize large-scale motion or defocus patterns. Dilated convolutions or multi-scale branches can be employed to improve robustness across varying blur intensities. By training on diverse blur types (e.g., camera shake, object motion, depth variation), the CNN develops generalized representations. This learning enables the model to infer missing or corrupted details and restore sharp textures that may not be recoverable through conventional filters. The result is a high-quality restoration with perceptually realistic outputs.

3.4.5 Integration point within the pipeline

In this hybrid deblurring pipeline, the CNN is the feature restoration step (noted as the y step) located after a noise reduction stage (e.g., noise reduction via NLM or other denoising approaches) and before a refinement step (e.g., using IIBP). The CNN’s feature learning capabilities will help recover the high frequency details and textures missing due to blur. After the random noise is reduced and structural edges preserved via NLM, the denoised image will be presented as the input to the CNN, with the goal of learning and correcting spatial distortions due to either motion or defocus blur artifacts. Within the context of these pipelines, the CNN will always get an image input where random noise has been suppressed. This allows the CNN to focus on reconstructing the features of the object with spatial distortion or blur, rather than using a neural network to denoise.

The CNN's outputs will then also be refined by the iterative Inverse Back Projection (IIBP), which optimizes the original image fidelity in relation to the observed blurry image following known deblurring physical models. The layered complexity of the hybrid allows the system to generate results that blend the learnt representation from the CNN with physical refinements, which enables balanced results that are both sharp yet still similar to the reference observation.

3.5 Improved Iterative Back Projection: Mathematical underpinnings of Iterative Inverse Back Projection

The theoretical underpinnings of Improved Iterative Back Projection (IIBP) are the inverse problem of image formation, i.e., restoring a sharp image from a blurred (by a blurring kernel H) image and adding noise to:

$B=H * I+n$          (10)

The observed blurred image is represented as a tensor B ∈ ℝ^{(H × W × C)}, where, H, W, and C denote image height, width, and color channels, respectively. The restored sharp image is denoted as I ∈ ℝ^{(H × W × C)}, while the blur kernel is represented by H ∈ ℝ^{(k × k)}, where, k indicates the kernel size. During DCNN training, mini-batch inputs are represented as tensors of dimension N × C × H × W, where N denotes batch size. Intermediate feature maps generated by convolutional layers maintain spatial dimensions according to kernel padding and stride configurations.

$I^{(t+1)}=I^{(t)}+\alpha H^T\left(B-H * I^{(t)}\right)$          (11)

This formulation treats the error as feedback and adjusts the image estimate, gradually improving the sharpness while maintaining consistency with the blur model.

3.5.1 Iterative refinement steps

IIBP improves image quality through iterative refinement, leveraging a feedback mechanism that minimizes the difference between the simulated blur and the actual observed image. The algorithm follows these key steps:

1. Initialization: Start with an initial image estimate I⁽⁰⁾, typically the output from a prior deblurring stage (e.g., DCNN).

2. Forward Projection: Apply the blur kernel HHH to simulate the blurred version of the current estimate:

$B^{(t)}=H * I^{(t)}$          (12)

3. Compute Residual: Calculate the difference between the observed blurred image and the simulated blur:

$e^{(t)}=B-B^{(t)}$          (13)

4. Repeat: Iterate until the residual is sufficiently small or a fixed number of iterations is reached.

These steps iteratively correct the estimated image, bringing it closer to a physically consistent and visually sharp reconstruction as given in Figure 2.

tu_pian_3.png

Figure 2. Iterative strategy

3.5.2 Role in correcting reconstruction errors

In a hybrid deblurring pipeline, IIBP plays a crucial role in correcting reconstruction errors introduced by earlier methods, such as CNN-based deblurring. While deep learning models excel at restoring textures and sharpness, they may hallucinate details or produce outputs that are inconsistent with the original blur model. IIBP addresses this by enforcing fidelity to the observed data. By comparing the blurred version of the estimated image with the actual blurred input, IIBP computes a residual that reflects areas where the reconstruction deviates from the true degradation process. This residual is back-projected to adjust the estimate, gradually correcting over- or under-sharpened regions.

IIBP ensures that the final deblurred output adheres to the known or estimated blur kernel, enhancing physical plausibility. It acts as a regularizing refinement step, balancing data-driven reconstruction from CNNs with model-based correction, thus improving both quantitative accuracy and visual realism in the final restored image.

3.6 Cubic B-spline interpolation

Spline-based interpolation is favored in image processing due to its ability to model smooth and continuous curves with high precision. Unlike linear or nearest-neighbor interpolation, which can introduce jagged edges or blocky artifacts, spline interpolation ensures smooth transitions between pixel intensities, making it ideal for high-quality image reconstruction and resizing.

The motivation for using splines arises when reconstructing sub-pixel information or resampling images during transformations (e.g., rotation, warping, scaling) involved in deblurring pipelines. Splines, especially cubic B-splines, offer a good trade-off between computational efficiency and reconstruction quality. They minimize interpolation error by fitting piecewise polynomial functions that ensure continuity up to the second derivative, preserving natural image gradients.

In hybrid deblurring, spline interpolation is particularly useful for aligning blurred and sharp patches or reprojecting residuals in iterative methods like IIBP, ensuring that pixel transitions remain visually seamless and mathematically accurate across the image.

3.6.1 Implementation strategy

The implementation of spline-based interpolation typically involves using piecewise polynomial functions, most commonly cubic B-splines, which interpolate data by fitting smooth curves through control points (pixel intensities). The process consists of the following steps:

• Grid Sampling: Identify pixel grid points in the image where interpolation is needed (e.g., non-integer coordinates due to transformation);
• Spline Basis Calculation: For each interpolation point, compute the contribution of neighboring pixels using predefined B-spline basis functions;
• Weighted Summation: Combine neighboring pixel values weighted by their corresponding spline coefficients:

$I(x)=\sum_i B_i(x) \cdot I_i$            (14)

Efficient implementations use recursive filtering and precomputed kernels to accelerate spline evaluations. In practice, spline interpolation is integrated into image libraries (e.g., OpenCV, SciPy) or customized in deblurring pipelines to handle transformations and residual updates with high spatial precision.

3.6.2 Contribution to smoothness and accuracy in image reconstruction

Spline-based interpolation significantly enhances the smoothness and accuracy of image reconstruction by providing a mathematically continuous model for intensity variation across pixels. In tasks like deblurring, where pixel shifts and gradients are critical, splines preserve the natural flow of structures—such as edges and textures—by avoiding the harsh transitions caused by lower-order interpolations.

The smoothness is attributable to the spline's capability for retaining continuous first and second derivatives, which minimizes artifacts such as ringing, aliasing, or staircasing. This adds value when using iterative methods (i.e., IIBP), where there are frequent updates to pixel values with the restriction of visual stability. Spline interpolation adds accuracy because it can more accurately approximate the true underlying image signal that occurred between samples, especially with operations such as sub-pixel alignment, residual correction, and patch comparison. As a result, we expect an output image that is more visually aesthetic, rather than quantitatively true to the original scene, with improved edge localization and less reconstruction error.

3.7 System integration workflow: Sequential flow of each component

The proposed hybrid framework follows a sequential multi-stage restoration pipeline. Each stage addresses a specific degradation component, including noise suppression, feature reconstruction, and residual correction. This design improves restoration stability and visual fidelity. Figure 3 illustrates the structural components of the proposed hybrid deblurring architecture. Subfigure (a) represents intra-stage long-term dependency modeling within individual modules like NLM and DCNN, capturing repetitive patterns and spatial correlations. Subfigure (b) shows inter-stage dependency modeling where outputs from denoising, feature restoration, and refinement stages are concatenated (⊕) to enhance information flow and integration. Subfigure (c) depicts a dual-gating feedforward network embedded within the DCNN, which selectively emphasizes edge-aware features while suppressing noise and irrelevant textures. This design strengthens detail preservation, structural coherence, and deblurring performance across diverse image conditions.

3.7.1 End-to-end process outline in stepwise format or pseudocode

The proposed hybrid deblurring architecture follows a sequential multi-stage workflow, integrating denoising, deep learning-based reconstruction, iterative refinement, and interpolation. The process begins by inputting a blurred image, denoted as B. To suppress noise and preserve fine structural details, the image is first processed using the NLM algorithm, producing a denoised version, I_NLM. This denoised image serves as a stable and clean input for the next stage.

In the second stage, the output from NLM is fed into a pretrained DCNN that is trained on paired blurred and sharp images. The DCNN restores high-frequency components and sharp textures, producing an intermediate deblurred image I_DCNN. To further refine this output and enforce physical consistency with the observed blur, the system applies the IIBP method.

tu_pian_4.png

Figure 3. Structural representation of the proposed hybrid deblurring framework: (a) intra-stage long-range dependency modeling within the Non-Local Means (NLM) and deep convolutional neural network (DCNN) components, (b) inter-stage dependency modeling between denoising, feature restoration, and improved iterative back projection (IIBP) refinement stages (⊕ denotes concatenation), (c) the dual-gating feedforward network integrated within the DCNN for enhanced edge-aware feature propagation

At the beginning of IIBP, the current image estimate I_current is initialized as IDCNN, and the blur kernel H is estimated from the original blurred input. A fixed learning rate α and iteration count are set. For each iteration, the estimated blur B^(t) = H ∗ I^(t) is computed by convolving the current estimate with the blur kernel. The residual error between the observed blurred image B and its estimate B(t) is computed; it is back projected using the transpose of the blur kernel and added to the current estimate for the remaining iterations of this process. After the specified number of iterations for the guided deblurring, the output B* is refined as a cubic B-spline interpolation of B1 and B2, which yields an image smoother than itself while taking care of possible contributions to sub-pixel misalignments introduced during the previous steps of the processing chain. Ultimately, the very recent and deblurred image, denoted Ifinal, has been denoised, restored to its deep features, corrected through iterative correction, and interpolated, thereby fulfilling all of the objectives we posed for the output. This comprehensive pipeline will deliver a high-fidelity, edge-preserving restoration suitable for diverse imaging applications in practice. This process tightly couples denoising and learned deblurring, with an additional layer of model-based refinement, in a cohesive and interpretable workflow that addresses noise suppression, restoration of sharpness in features, and fidelity to the input image.

3.7.2 Edge-aware loss function for enhanced structural preservation

To further improve the restoration of sharp details and edge consistency, we integrate an Edge-Aware Loss Function into the training process of the DCNN. Traditional loss functions like MSE often produce overly smooth results, especially in regions with high-frequency content such as edges or textures. The Edge-Aware Loss overcomes this limitation by penalizing errors in both pixel intensities and spatial gradients.

Formulation of Edge-Aware Loss Let $I_{\text {DCNN }}$ be the output of the CNN and $I_{\mathrm{GT}}$ be the ground-truth sharp image. The Edge-Aware Loss $L_{\text {total }}$ is defined as:

$\begin{array}{r}L_{\text {total }}=\lambda_1 \cdot \underbrace{\left\|I_{\mathrm{DCNN}}-I_{\mathrm{GT}}\right\|^2}_{\text {Pixel Fidelity Loss }}+\lambda_2 \\ \cdot \underbrace{\left\|\nabla I_{\mathrm{DCNN}}-\nabla I_{\mathrm{GT}}\right\|^2}_{\text {Edge Consistency Loss }}\end{array}$          (15)

• $\nabla$ denotes the gradient operator (e.g., Sobel or Scharr filter) applied to horizontal and vertical directions;
• $\lambda_1$ and $\lambda_2$ are weighting factors balancing pixel fidelity and edge preservation;
• The gradient loss ensures that sharp transitions (edges) in the image are restored correctly, enhancing visual quality and structural coherence. © Training Strategy with Edge-Aware Supervision: The network is trained end-to-end on paired datasets of blurred and sharp images. During training:
• The pixel fidelity loss encourages general similarity in brightness and content;
• The edge consistency loss forces the model to pay special attention to restoring gradients, which represent edges and fine contours;
• Backpropagation is performed using the combined loss $L_{\text {total }}$, guiding the network to learn edge-aware representations.

This dual-focus training strategy helps suppress artifacts and hallucinations common in purely pixel-wise losses while preserving perceptual sharpness in the output. Table 2 gives the description of all the symbols utilized.

Table 2. Symbol definitions used in the proposed framework

The proposed Edge-Aware Training Algorithm aims to improve the non-local capabilities of DCNNs in image deblurring applications by adding structural preservation as part of the learning. Training methods based solely on pixel-wise losses, such as MSE, for example, often lead to pleasingly smooth results that do not retain sharp edges or fine details that are essential for visual understanding. The proposed edge-aware training algorithm leverages an edge-aware learning approach that controls the network to learn edge structures to support image fidelity. The proposed algorithm uses a multi-loss function (two) to balance pixel fidelity and consistency in gradient levels during the training process. During training, the DCNN is given paired images, micro-batches of blurred and ground truth sharp images. For each micro-batch, the DCNN first predicts a deblurred image from the blurred images fed into the network using a forward pass. In this step, a pixel fidelity loss value is obtained from the predicted image using the squared difference between the predicted and the true representation of the image that captures at least some general image content. In parallel, the gradients of the predicted and the ground truth images are produced using edge operators such as Sobel or Scharr filters, which we refer to as the gradient of the images as a way to produce low-level instruction relying on structural information of edges and contours. The edge consistency loss value is produced utilizing the squared difference histogram, which produces a value for edge consistency loss by measuring the squared differences between values of the edges of the predicted and true image edge output images. The total loss function is equal to the defined weighted loss function of the pixel and edge losses, where the control of these two losses is determined by the hyperparameters.

3.7.3 Training workflow of the proposed framework

The training workflow of the proposed framework follows a sequential restoration strategy. Initially, the blurred input image undergoes NLM denoising to suppress stochastic noise while preserving structural information. The denoised image is then passed through the Transformer-enhanced DCNN module, which learns high-frequency feature restoration using paired blurred–sharp training samples. During optimization, the proposed Edge-Aware Loss Function simultaneously minimizes pixel reconstruction error and spatial gradient inconsistency in Figure 4. The output generated by the DCNN is subsequently refined using IIBP, which iteratively minimizes reconstruction residuals according to the forward blur degradation model. Finally, Cubic B-Spline interpolation is employed to improve sub-pixel smoothness and structural continuity in the reconstructed image.

tu_pian_5.png

Figure 4. Training workflow of the proposed hybrid deblurring framework