运动模糊修复：4 类实用算法及 OpenCV+Halcon 实战代码

2. 算法 2：盲去卷积（Blind Deconvolution）——自动估核，适配未知模糊核场景

• 核心逻辑：无需提前知道模糊核，算法会同时估计模糊核和清晰图像，通过迭代优化还原细节，最常用的是 Richardson-Lucy（RL）盲去卷积；
• 适用场景：模糊核未知的匀速运动模糊，比如产线速度波动、多方向运动的零件（如齿轮旋转检测）；
• 优势：无需提前标定，适配性强，能应对大部分工业匀速运动模糊；
• 局限：迭代计算量比维纳滤波大，实时性略低（单帧处理约 10ms），非匀速模糊修复效果一般。

关键调参：迭代次数是核心，工业场景中迭代 20-50 次即可平衡效果与速度，次数过多易出现噪声放大。

3. 算法 3：非均匀去模糊（Non-uniform Deconvolution）——应对复杂运动模糊

• 核心逻辑：针对非匀速运动模糊（如相机抖动、零件旋转 + 平移），将图像分块，为每个区块估计不同的模糊核，再分别进行去卷积修复；
• 适用场景：复杂运动模糊场景，比如汽车零部件的旋转加工检测、无人机巡检的工业设备图像修复；
• 优势：能处理传统算法无法解决的非匀速模糊，修复后细节保留更完整；
• 局限：计算量大，实时性差（单帧处理约 50ms），仅适合中低速产线或离线检测。

4. 算法 4：深度学习去模糊（Deep Learning-based Deblurring）——复杂场景终极方案

• 核心逻辑：用大量'运动模糊图像 - 清晰图像'的配对样本训练深度学习模型（如 CNN、GAN、UNet），模型直接学习模糊到清晰的映射关系，无需估计模糊核；
• 常用模型：DeblurGAN、MPRNet、Restormer（工业场景中 Restormer 兼顾速度与精度）；
• 优势：
  • 抗干扰能力强：能同时处理运动模糊、噪声、光照变化；
  • 适配复杂场景：不管是匀速还是非匀速模糊，都能稳定输出清晰图像；
• 适用场景：极端复杂的运动模糊场景（如高速旋转的精密零件、低光照下的动态检测）；
• 落地注意：需要 GPU 加速（如 NVIDIA Jetson Xavier），小批量场景标注成本高，适合大批量工业检测。

🎯三、实战代码：OpenCV+Halcon 实现运动模糊修复

1. OpenCV 实现（维纳滤波+RL 盲去卷积）

import cv2
import numpy as np
from scipy import signal
from scipy.fft import fft2, ifft2

def motion_kernel(length, angle):
    """生成运动模糊核（PSF）"""
    angle = np.deg2rad(angle)
    kernel = np.zeros((length, length))
    center = length // 2
    # 计算模糊核的像素坐标
    x = np.linspace(-center, center, length)
    y = np.round(x * np.tan(angle)).astype(int)
    for i in range(length):
        if center + y[i] >= 0 and center + y[i] < length:
            kernel[center + y[i], i] = 1
    # 归一化模糊核
    kernel = kernel / kernel.sum()
    return kernel

def wiener_deblur(img, kernel, K=0.01):
    """维纳滤波去模糊"""
    # 傅里叶变换
    img_fft = fft2(img)
    kernel_fft = fft2(kernel, s=img.shape)
    # 维纳滤波公式
    kernel_fft_conj = np.conj(kernel_fft)
    wiener = kernel_fft_conj / (np.abs(kernel_fft)**2 + K)
    img_deblur_fft = img_fft * wiener
    # 逆傅里叶变换
    img_deblur = np.abs(ifft2(img_deblur_fft))
    img_deblur = np.uint8(np.clip(img_deblur, 0, 255))
    return img_deblur

def rl_blind_deconvolution(img, iterations=30):
    """Richardson-Lucy 盲去卷积"""
    img = img.astype(np.float32)
    # 初始化估计的清晰图像
    img_est = np.copy(img)
    # 初始化模糊核（先假设为小核）
    kernel = np.ones((5, 5)) / 25
    for i in range(iterations):
        # 卷积操作
        img_blur_est = signal.convolve2d(img_est, kernel, mode='same', boundary='symm')
        # 计算残差
        ratio = img / (img_blur_est + 1e-6)
        # 反卷积更新
        img_est *= signal.convolve2d(ratio, np.flip(kernel), mode='same', boundary='symm')
        img_est = np.uint8(np.clip(img_est, 0, 255))
    return img_est

# 测试代码
if __name__ == "__main__":
    # 读取运动模糊图像（替换为你的图像路径）
    img = cv2.imread("motion_blur.jpg", 0)
    # 1. 维纳滤波去模糊（已知模糊核：长度 15 像素，水平 0 度）
    kernel = motion_kernel(15, 0)
    img_wiener = wiener_deblur(img, kernel)
    # 2. RL 盲去卷积去模糊
    img_rl = rl_blind_deconvolution(img, iterations=30)
    # 拼接显示结果
    result = np.hstack((img, img_wiener, img_rl))
    cv2.imwrite("deblur_result.jpg", result)
    cv2.imshow("Original | Wiener | RL Blind Deconvolution", result)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

2. Halcon 实现（维纳滤波 + 盲去卷积）

dev_close_window()
dev_open_window(0, 0, 1200, 400, 'black', WindowHandle)
*1. 读取图像与参数设置
read_image(ImgBlur, 'motion_blur.jpg') // 运动模糊图像
get_image_size(ImgBlur, Width, Height)
convert_image_type(ImgBlur, ImgBlurFloat, 'real')
*2. 生成运动模糊核（长度 15 像素，水平方向）
gen_kernel_motion(Kernel, 15, 0, 'constant', 'normalized')
*3. 维纳滤波去模糊
wiener_filter(ImgBlurFloat, ImgWiener, Kernel, 0.01, 'none')
convert_image_type(ImgWiener, ImgWienerByte, 'byte')
*4. 盲去卷积（Richardson-Lucy）
deconvolve_blind(ImgBlurFloat, ImgRL, Kernel, 30, 1, 'rl')
convert_image_type(ImgRL, ImgRLByte, 'byte')
*5. 显示结果
dev_display(ImgBlur)
disp_message(WindowHandle, 'Original Motion Blur', 'window', 10, 10, 'black', 'true')
dev_set_window_pos(WindowHandle, 0, Width + 20)
dev_display(ImgWienerByte)
disp_message(WindowHandle, 'Wiener Filter', 'window', 10, 10, 'black', 'true')
dev_set_window_pos(WindowHandle, 0, 2*Width + 40)
dev_display(ImgRLByte)
disp_message(WindowHandle, 'RL Blind Deconvolution', 'window', 10, 10, 'black', 'true')
* 输出统计信息
get_image_grayval(ImgBlur, Width/2, Height/2, GrayValBlur)
get_image_grayval(ImgWienerByte, Width/2, Height/2, GrayValWiener)
disp_message(WindowHandle, 'Blur Gray Value: ' + GrayValBlur, 'window', 30, 10, 'black', 'true')
disp_message(WindowHandle, 'Wiener Gray Value: ' + GrayValWiener, 'window', 30, 10, 'black', 'true')

代码关键说明

• OpenCV 版：手动实现运动模糊核生成，同时提供维纳滤波（已知核）和 RL 盲去卷积（未知核）两种方案，方便根据场景选择；
• Halcon 版：调用内置的 gen_kernel_motion 和 wiener_filter 函数，更贴近工业视觉的实际应用，deconvolve_blind 函数简化了盲去卷积的迭代过程；
• 参数调整：维纳滤波的 K 值（噪声系数）可根据图像噪声调整，噪声大时调大 K（如 0.05）；RL 盲去卷积的迭代次数，高速产线建议设为 20 次，离线检测可设为 50 次。

🎯四、工业落地：3 个关键技巧，让修复更稳定

1. 先优化硬件，再用算法

• 缩短曝光时间：这是最根本的方法，将相机曝光时间从 10ms 降至 1ms，能直接减少运动模糊的长度（但需搭配高亮度光源，避免图像过暗）；
• 使用全局快门相机：卷帘快门相机会导致物体边缘扭曲，全局快门相机能同步曝光所有像素，适合高速运动物体。

2. 提前标定模糊核，提升算法效率

• 针对固定产线速度，提前拍摄不同速度下的标定板图像，计算对应的模糊长度和方向，保存为模糊核库；
• 检测时根据产线速度调用对应的模糊核，用维纳滤波快速修复，比盲去卷积快 5 倍以上。

3. 图像预处理，减少噪声干扰

• 去模糊前对图像做高斯滤波（5×5 核） 或中值滤波，降低噪声，避免去模糊后噪声放大；
• 对低对比度图像做直方图均衡化，增强细节，让修复效果更明显。

🎯五、避坑指南：3 个常见误区

1. 误区 1：'算法能解决所有运动模糊'——如果曝光时间过长（如 50ms），物体在图像中完全拖影，再优秀的算法也无法还原细节，优先优化硬件；
2. 误区 2：'迭代次数越多，修复效果越好'——迭代次数过多会放大图像噪声，出现伪影，工业场景 20-50 次足够；
3. 误区 3：'所有场景都用深度学习去模糊'——深度学习需要大量样本和 GPU，常规匀速模糊用维纳滤波或盲去卷积即可，性价比更高。

🎯六、总结：运动模糊修复的'核心策略'

运动模糊修复的关键是**'硬件优先，算法适配'**：先通过缩短曝光时间、使用全局快门相机减少模糊，再根据模糊核是否已知选择算法——

• 已知模糊核：用维纳滤波（高速产线首选）；
• 未知模糊核：用 RL 盲去卷积（中速产线）；
• 复杂非匀速模糊：用分块非均匀去模糊或深度学习（离线/低速检测）。

4 类算法从简单到复杂，按需选择就能在高速产线中拿到清晰图像，搞定缺陷检测和尺寸测量。