图像处理-python–维纳滤波实现恢复运动中的模糊图像

图像处理-python–维纳滤波实现恢复运动中的模糊图像

说明：源代码源自于网络，要根据图像的模糊程度来对K值和一些相关的参数进行修改。
1.先给大家看下结果哈：

2.大家关心的代码:

import matplotlib.pyplot as plt
import numpy as np
from numpy import fft
import math
import cv2


# 仿真运动模糊
def motion_process(image_size, motion_angle):
    PSF = np.zeros(image_size)
    print(image_size)
    center_position = (image_size[0] - 1) / 2
    print(center_position)

    slope_tan = math.tan(motion_angle * math.pi / 180)  #取一个数的正切值
    slope_cot = 1 / slope_tan
    if slope_tan <= 1:
        for i in range(120):
            offset = round(i * slope_tan)  # ((center_position-i)*slope_tan)    round():四舍五入，将float变为int
            PSF[int(center_position + offset), int(center_position + offset)] = 1
        return PSF / PSF.sum()  # 对点扩散函数进行归一化亮度
    else:
        for i in range(120):
            offset = round(i * slope_cot)
            PSF[int(center_position - offset), int(center_position - offset)] = 1
        return PSF / PSF.sum()
# 对图片进行运动模糊
def make_blurred(input, PSF, eps):
    input_fft = fft.fft2(input)  # 进行二维数组的傅里叶变换
    PSF_fft = fft.fft2(PSF) + eps
    blurred = fft.ifft2(input_fft * PSF_fft)
    blurred = np.abs(fft.fftshift(blurred))
    return blurred
def inverse(input, PSF, eps):  # 逆滤波
    input_fft = fft.fft2(input)
    PSF_fft = fft.fft2(PSF) + eps  # 噪声功率，这是已知的，考虑epsilon
    result = fft.ifft2(input_fft / PSF_fft)  # 计算F(u,v)的傅里叶反变换
    result = np.abs(fft.fftshift(result))
    return result


def wiener(input, PSF, eps, K=0.0001):  # 维纳滤波，K=0.0001
    input_fft = fft.fft2(input)
    PSF_fft = fft.fft2(PSF) + eps
    PSF_fft_1 = np.conj(PSF_fft) / (np.abs(PSF_fft) ** 2 + K)
    result = fft.ifft2(input_fft * PSF_fft_1)
    result = np.abs(fft.fftshift(result))
    return result


def normal(array):
    array = np.where(array < 0, 0, array)
    array = np.where(array > 255, 255, array)
    array = array.astype(np.int16)
    return array

def main(gray):
    channel = []
    img_h, img_w = gray.shape[:2]
    PSF = motion_process((img_h, img_w), 60)  # 进行运动模糊处理
    blurred = np.abs(gray)

    result_blurred = inverse(blurred, PSF, 1e-3)  # 逆滤波
    result_wiener = wiener(blurred, PSF, 1e-3)  # 维纳滤波

    blurred_noisy = blurred + 0.1 * blurred.std() * \
                    np.random.standard_normal(blurred.shape)  # 添加噪声,standard_normal产生随机的函数
    inverse_mo2no = inverse(blurred_noisy, PSF, 0.1 + 1e-3)  # 对添加噪声的图像进行逆滤波
    wiener_mo2no = wiener(blurred_noisy, PSF, 0.1 + 1e-3)  # 对添加噪声的图像进行维纳滤波
    channel.append((normal(blurred), normal(result_blurred), normal(result_wiener),
                    normal(blurred_noisy), normal(inverse_mo2no), normal(wiener_mo2no)))
    return channel


if __name__ == '__main__':
    image = cv2.imread('book-cover-blurred.tif')
    b_gray, g_gray, r_gray = cv2.split(image.copy())

    Result = []
    for gray in [b_gray, g_gray, r_gray]:
        channel = main(gray)
        Result.append(channel)
    blurred = cv2.merge([Result[0][0][0], Result[1][0][0], Result[2][0][0]])
    result_blurred = cv2.merge([Result[0][0][1], Result[1][0][1], Result[2][0][1]])
    result_wiener = cv2.merge([Result[0][0][2], Result[1][0][2], Result[2][0][2]])
    blurred_noisy = cv2.merge([Result[0][0][3], Result[1][0][3], Result[2][0][3]])
    inverse_mo2no = cv2.merge([Result[0][0][4], Result[1][0][4], Result[2][0][4]])
    wiener_mo2no = cv2.merge([Result[0][0][5], Result[1][0][5], Result[2][0][5]])

    # ========= 可视化 ==========
    # plt.figure(1)
    # plt.xlabel("Original Image")
    # plt.imshow(np.flip(image, axis=2))  # 显示原图像

    #plt.figure()
    #plt.figure(figsize=(8, 6.5))
    imgNames = {"Original":image,"wiener deblurred(k=0.0001)":result_wiener}
    for i, (key,imgName) in enumerate(imgNames.items()):
        plt.subplot(121+i)
        plt.xlabel(key)
        plt.imshow(np.flip(imgName, axis=2))
    plt.show()

3.跑了大半个网络，找了很多不太适合的 这有这个还行吧 希望这个对大家学习有点帮助