图像去模糊算法代码实践：从理论到实战

图像去模糊是计算机视觉领域的核心任务之一，其目标是通过算法恢复因运动、对焦失误或环境干扰导致的模糊图像。本文将从经典算法到深度学习模型，结合代码实践，系统性地探讨图像去模糊的实现路径，为开发者提供可复用的技术方案。

一、图像模糊的成因与数学模型

图像模糊的本质是原始清晰图像与模糊核（Point Spread Function, PSF）的卷积过程，数学表达式为：
[ I{\text{blur}} = I{\text{sharp}} \otimes k + n ]
其中，( I{\text{blur}} )为模糊图像，( I{\text{sharp}} )为清晰图像，( k )为模糊核，( n )为噪声。常见的模糊类型包括：

1. 运动模糊：相机或物体快速移动导致，模糊核呈线性。
2. 高斯模糊：由镜头散焦或传感器噪声引起，模糊核近似高斯分布。
3. 离焦模糊：对焦不准导致，模糊核与景深相关。

代码示例：生成模拟模糊图像

import cv2
import numpy as np
def generate_motion_blur(image, kernel_size=15, angle=45):
    kernel = np.zeros((kernel_size, kernel_size))
    center = kernel_size // 2
    cv2.line(kernel, (center, 0), (center, kernel_size-1), 1, 1)
    kernel = rotate_image(kernel, angle)
    kernel /= kernel.sum()  # 归一化
    blurred = cv2.filter2D(image, -1, kernel)
    return blurred
def rotate_image(image, angle):
    rows, cols = image.shape
    M = cv2.getRotationMatrix2D((cols/2, rows/2), angle, 1)
    rotated = cv2.warpAffine(image, M, (cols, rows))
    return rotated
# 测试
image = cv2.imread('input.jpg', 0)  # 读取灰度图
blurred = generate_motion_blur(image)
cv2.imwrite('blurred.jpg', blurred)

此代码通过生成线性模糊核并旋转角度，模拟运动模糊效果，为后续去模糊算法提供测试数据。

二、经典去模糊算法：逆滤波与维纳滤波

1. 逆滤波（Inverse Filtering）

逆滤波通过频域反卷积恢复图像，公式为：
[ \hat{I}{\text{sharp}} = \mathcal{F}^{-1}\left( \frac{\mathcal{F}(I{\text{blur}})}{\mathcal{F}(k) + \epsilon} \right) ]
其中，( \epsilon )为小常数以避免除零错误。

代码实现

def inverse_filtering(blurred, kernel, epsilon=1e-3):
    # 频域转换
    blurred_fft = np.fft.fft2(blurred)
    kernel_fft = np.fft.fft2(kernel, s=blurred.shape)
    # 逆滤波
    restored_fft = blurred_fft / (kernel_fft + epsilon)
    restored = np.fft.ifft2(restored_fft).real
    # 裁剪到0-255范围
    restored = np.clip(restored, 0, 255).astype(np.uint8)
    return restored
# 测试
kernel = np.ones((15, 15))  # 简单均匀核（实际需匹配模糊核）
restored = inverse_filtering(blurred, kernel)

局限性：逆滤波对噪声敏感，且要求精确已知模糊核，实际应用中效果有限。

2. 维纳滤波（Wiener Filtering）

维纳滤波引入噪声功率谱比（SNR）优化反卷积，公式为：
[ \hat{I}{\text{sharp}} = \mathcal{F}^{-1}\left( \frac{\mathcal{F}(k)^* \cdot \mathcal{F}(I{\text{blur}})}{|\mathcal{F}(k)|^2 + K} \right) ]
其中，( K )为噪声与信号的功率比。

代码实现

def wiener_filtering(blurred, kernel, K=0.01):
    blurred_fft = np.fft.fft2(blurred)
    kernel_fft = np.fft.fft2(kernel, s=blurred.shape)
    kernel_fft_conj = np.conj(kernel_fft)
    # 维纳滤波公式
    numerator = kernel_fft_conj * blurred_fft
    denominator = np.abs(kernel_fft)**2 + K
    restored_fft = numerator / denominator
    restored = np.fft.ifft2(restored_fft).real
    return np.clip(restored, 0, 255).astype(np.uint8)
# 测试
restored_wiener = wiener_filtering(blurred, kernel)

优势：维纳滤波通过引入噪声参数，显著提升了抗噪能力，但需预先估计噪声水平。

三、深度学习去模糊：基于卷积神经网络的解决方案

传统方法依赖模糊核的精确估计，而深度学习通过数据驱动的方式直接学习模糊到清晰的映射。以下介绍两种典型模型：

1. SRN-DeblurNet：多尺度循环网络

SRN-DeblurNet通过多尺度特征提取和循环结构逐步去模糊，其核心思想是将大模糊分解为小尺度任务。

代码框架（PyTorch示例）

import torch
import torch.nn as nn
import torchvision.models as models
class SRNDeblurNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.encoder = models.vgg16(pretrained=True).features[:23]  # 提取浅层特征
        self.decoder = nn.Sequential(
            nn.Conv2d(512, 256, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(256, 3, 3, padding=1),  # 输出清晰图像
            nn.Sigmoid()
        )
        self.lstm = nn.LSTM(512, 256, num_layers=2)  # 循环结构
    def forward(self, x):
        features = self.encoder(x)
        batch_size, channels, height, width = features.shape
        features_flat = features.permute(1, 0, 2, 3).reshape(channels, -1)
        # LSTM处理特征序列
        lstm_out, _ = self.lstm(features_flat.unsqueeze(0))
        lstm_out = lstm_out.squeeze(0).reshape(batch_size, channels, height, width)
        return self.decoder(lstm_out)
# 训练伪代码
model = SRNDeblurNet()
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
for epoch in range(100):
    for blurred, sharp in dataloader:
        restored = model(blurred)
        loss = criterion(restored, sharp)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

特点：SRN-DeblurNet通过LSTM捕捉时序依赖，适合处理复杂运动模糊。

2. DeblurGANv2：生成对抗网络

DeblurGANv2采用生成器-判别器架构，生成器负责去模糊，判别器区分真实与生成图像。

关键代码片段

class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.downsample = nn.Sequential(
            nn.Conv2d(3, 64, 7, stride=1, padding=3),
            nn.ReLU(),
            nn.Conv2d(64, 128, 3, stride=2, padding=1),
            nn.ReLU()
        )
        self.upsample = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 3, 7, stride=1, padding=3),
            nn.Sigmoid()
        )
    def forward(self, x):
        x = self.downsample(x)
        return self.upsample(x)
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 64, 4, stride=2, padding=1),
            nn.LeakyReLU(0.2),
            nn.Conv2d(64, 128, 4, stride=2, padding=1),
            nn.LeakyReLU(0.2),
            nn.Conv2d(128, 1, 4, stride=1, padding=1)  # 输出0-1的判别结果
        )
    def forward(self, x):
        return torch.sigmoid(self.model(x))

训练技巧：

• 使用Wasserstein GAN损失（WGAN-GP）提升稳定性。
• 结合L1损失保证像素级准确性。

四、实践建议与优化方向

1. 数据准备：

   • 构建成对模糊-清晰数据集（如GoPro数据集）。
   • 数据增强：随机旋转、缩放、添加噪声。

2. 模型选择：

   • 轻量级场景：优先选择SRN-DeblurNet或U-Net变体。
   • 高质量需求：采用DeblurGANv2或Transformer架构（如Restormer）。

3. 评估指标：

   • PSNR（峰值信噪比）：衡量像素级误差。
   • SSIM（结构相似性）：评估视觉质量。
   • LPIPS（感知损失）：基于深度特征的相似性。

4. 部署优化：

   • 模型量化：将FP32转换为INT8以减少计算量。
   • TensorRT加速：提升推理速度。

五、总结与展望

图像去模糊算法从传统频域方法发展到深度学习模型，实现了从“理论假设”到“数据驱动”的跨越。开发者可根据场景需求选择合适方案：

• 快速原型开发：维纳滤波或SRN-DeblurNet。
• 工业级应用：DeblurGANv2或Transformer模型。
  未来方向包括无监督去模糊、实时视频去模糊以及跨模态去模糊（如结合事件相机数据）。通过持续优化算法与工程实践，图像去模糊技术将在自动驾驶、医疗影像等领域发挥更大价值。