频率域图像滤波算法

对图像进行离散傅里叶变换

在像素变化明显的地方，频率高，离散傅里叶变换之后所对应的频率谱对应的像素值也就越大

理想低通滤波器
在实际的硬件实现上，是无法实现理想低通滤波器的，但是在代码的实现上，是可以的。



可以看出来理想低通滤波器处理之后的图像有很明显的振铃

巴特沃斯低通滤波器

与理想低通滤波器不同，巴特沃斯的低通滤波器在通过频率和滤除频率间给出急剧不连续性

可以看出经过巴特沃斯低通滤波器的图像平滑性很好，同时没有明显的振铃

理想高通滤波器
和理想低通滤波器一样，硬件设备上是没有办法实现的


仍然可以看出，振铃较为明显

巴特沃斯高通滤波器

可以看出锐化效果很好，而且没有振铃

(放一张原图，大家对比一下效果）

代码实现如下：

# -*- coding: utf-8 -*-
"""
Created on 2021/4/20 15:38

# @Author  : desires19
"""
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import sys


def loading_image(path='E:\Documents\python_work\dip\example.jpg'):
    image = Image.open(path)
    image = np.asarray(image)
    r, g, b = image[:, :, 0], image[:, :, 1], image[:, :, 2]
    return r, g, b


def padding():
    r, g, b = loading_image()
    size = r.shape  # (799,640)
    re_size = (2 * size[0], 2 * size[1])
    p_r = np.asarray([0] * re_size[0] * re_size[1])
    p_g = np.asarray([0] * re_size[0] * re_size[1])
    p_b = np.asarray([0] * re_size[0] * re_size[1])
    p_r = p_r.reshape(re_size)
    p_g = p_g.reshape(re_size)
    p_b = p_b.reshape(re_size)
    # print(p.shape)
    col = 0
    row = 0
    while col < size[0]:
        while row < size[1]:
            p_r[col][row] = r[col][row] * pow(-1, col + row) + p_r[col][row]
            p_g[col][row] = g[col][row] * pow(-1, col + row) + p_g[col][row]
            p_b[col][row] = b[col][row] * pow(-1, col + row) + p_b[col][row]
            row += 1
        col += 1
        row = 0
    f_r = np.fft.fft2(p_r)
    f_g = np.fft.fft2(p_g)
    f_b = np.fft.fft2(p_b)
    return f_r, f_b, f_g


def lpf(D0):
    '''理想低通滤波器'''
    f_r, f_b, f_g = padding()
    (P, Q) = f_r.shape
    bw = np.zeros(P * Q)
    bw = bw.reshape(P, Q)
    col = 0
    row = 0
    while col < P:
        while row < Q:
            temp = pow(pow((col - P / 2), 2) + pow((row - Q / 2), 2), 0.5)
            if temp <= D0:
                bw[col][row] = 1
            row += 1
        col += 1
        row = 0
    r = np.fft.ifft2(np.multiply(f_r, bw))
    b = np.fft.ifft2(np.multiply(f_b, bw))
    g = np.fft.ifft2(np.multiply(f_g, bw))
    '''取实部'''
    gp_r = np.real(r)
    gp_b = np.real(b)
    gp_g = np.real(g)
    '''进行提取并进行反中心变换'''
    m = int(P / 2)
    n = int(Q / 2)
    g_r = np.zeros(m * n)
    g_b = np.zeros(m * n)
    g_g = np.zeros(m * n)
    g_r = g_r.reshape(m, n)
    g_b = g_b.reshape(m, n)
    g_g = g_g.reshape(m, n)
    col = 0
    row = 0
    while col < m:
        while row < n:
            g_r[col][row] = gp_r[col][row] * pow(-1, col + row)
            g_g[col][row] = gp_g[col][row] * pow(-1, col + row)
            g_b[col][row] = gp_b[col][row] * pow(-1, col + row)
            row += 1
        row = 0
        col += 1
    return g_r, g_g, g_b


def blpf(D0, n):
    '''
    巴特沃斯低通滤波器
    n 为 巴特沃斯滤波器的阶数
    '''
    f_r, f_b, f_g = padding()
    (P, Q) = f_r.shape
    butter_w = np.zeros(P * Q)
    butter_w = butter_w.reshape(P, Q)
    col = 0
    row = 0
    while col < P:
        while row < Q:
            temp = pow(pow((col - P / 2), 2) + pow((row - Q / 2), 2), 0.5)
            tmp = 1 / (1 + pow((temp / D0), 2 * n))
            butter_w[col][row] = tmp
            row += 1
        col += 1
        row = 0

    r = np.fft.ifft2(np.multiply(f_r, butter_w))
    b = np.fft.ifft2(np.multiply(f_b, butter_w))
    g = np.fft.ifft2(np.multiply(f_g, butter_w))
    '''取实部'''
    gp_r = np.real(r)
    gp_b = np.real(b)
    gp_g = np.real(g)
    '''进行提取并进行反中心变换'''
    m = int(P / 2)
    n = int(Q / 2)
    g_r = np.zeros(m * n)
    g_b = np.zeros(m * n)
    g_g = np.zeros(m * n)
    g_r = g_r.reshape(m, n)
    g_b = g_b.reshape(m, n)
    g_g = g_g.reshape(m, n)
    col = 0
    row = 0
    while col < m:
        while row < n:
            g_r[col][row] = gp_r[col][row] * pow(-1, col + row)
            g_g[col][row] = gp_g[col][row] * pow(-1, col + row)
            g_b[col][row] = gp_b[col][row] * pow(-1, col + row)
            row += 1
        row = 0
        col += 1
    return g_r, g_g, g_b


def hpf(D0):
    '''理想高通滤波器'''
    f_r, f_b, f_g = padding()
    (P, Q) = f_r.shape
    bw = np.zeros(P * Q)
    bw = bw.reshape(P, Q)
    col = 0
    row = 0
    while col < P:
        while row < Q:
            temp = pow(pow((col - P / 2), 2) + pow((row - Q / 2), 2), 0.5)
            if temp >= D0:
                bw[col][row] = 1
            row += 1
        col += 1
        row = 0

    r = np.fft.ifft2(np.multiply(f_r, bw))
    b = np.fft.ifft2(np.multiply(f_b, bw))
    g = np.fft.ifft2(np.multiply(f_g, bw))
    '''取实部'''
    gp_r = np.real(r)
    gp_b = np.real(b)
    gp_g = np.real(g)
    '''进行提取并进行反中心变换'''
    m = int(P / 2)
    n = int(Q / 2)
    g_r = np.zeros(m * n)
    g_b = np.zeros(m * n)
    g_g = np.zeros(m * n)
    g_r = g_r.reshape(m, n)
    g_b = g_b.reshape(m, n)
    g_g = g_g.reshape(m, n)
    col = 0
    row = 0
    while col < m:
        while row < n:
            g_r[col][row] = gp_r[col][row] * pow(-1, col + row)
            g_g[col][row] = gp_g[col][row] * pow(-1, col + row)
            g_b[col][row] = gp_b[col][row] * pow(-1, col + row)
            row += 1
        row = 0
        col += 1
    return g_r, g_g, g_b


def bhpf(D0, n):
    '''
    巴特沃斯低通滤波器
    n 为 巴特沃斯滤波器的阶数
    '''
    f_r, f_b, f_g = padding()
    (P, Q) = f_r.shape
    butter_w = np.zeros(P * Q)
    butter_w = butter_w.reshape(P, Q)
    col = 0
    row = 0
    while col < P:
        while row < Q:
            temp = pow(pow((col - P / 2), 2) + pow((row - Q / 2), 2), 0.5)
            tmp = 1 / (1 + pow((temp / D0), 2 * n))
            butter_w[col][row] = 1 - tmp
            row += 1
        col += 1
        row = 0

    r = np.fft.ifft2(np.multiply(f_r, butter_w))
    b = np.fft.ifft2(np.multiply(f_b, butter_w))
    g = np.fft.ifft2(np.multiply(f_g, butter_w))
    '''取实部'''
    gp_r = np.real(r)
    gp_b = np.real(b)
    gp_g = np.real(g)
    '''进行提取并进行反中心变换'''
    m = int(P / 2)
    n = int(Q / 2)
    g_r = np.zeros(m * n)
    g_b = np.zeros(m * n)
    g_g = np.zeros(m * n)
    g_r = g_r.reshape(m, n)
    g_b = g_b.reshape(m, n)
    g_g = g_g.reshape(m, n)
    col = 0
    row = 0
    while col < m:
        while row < n:
            g_r[col][row] = gp_r[col][row] * pow(-1, col + row)
            g_g[col][row] = gp_g[col][row] * pow(-1, col + row)
            g_b[col][row] = gp_b[col][row] * pow(-1, col + row)
            row += 1
        row = 0
        col += 1
    return g_r, g_g, g_b


def standardizing(r):
    '''标准化函数'''
    (m, n) = r.shape
    re = []

    max_num = np.max(r)
    min_num = np.min(r)
    range = max_num - min_num
    col = 0
    row = 0
    while col < m:
        while row < n:
            re.append(int(255 * (r[col][row] - min_num) / range))
            row += 1
        row = 0
        col += 1
    re = np.asarray(re)
    re = re.reshape(m, n)
    return re


def image_show(r, g, b, image_name):
    new_image = np.stack((r, g, b), axis=2)
    # print(new_image.shape)
    plt.imshow(new_image)  # 显示图片
    plt.axis('off')  # 不显示坐标轴
    plt.savefig(image_name, bbox_inches='tight')


def init():
    print("0为理想低通滤波")
    print("1为巴特沃斯低通滤波")
    print("2为理想高通滤波")
    print("3为巴特沃斯高通滤波")
    print("4为退出程序")
    key = input("请输入您想要进行的操作 ")
    return key


def switch(k):
    if k == 0:
        '''0为理想低通滤波'''
        g_r, g_g, g_b = lpf(50)
        r0 = standardizing(g_r)
        g0 = standardizing(g_g)
        b0 = standardizing(g_b)
        image_show(r0, g0, b0, 'E:\Documents\python_work\dip\out\\lpf.jpg')
    elif k == 1:
        '''1为巴特沃斯低通滤波'''
        g_r, g_g, g_b = blpf(50, 3)
        r1 = standardizing(g_r)
        g1 = standardizing(g_g)
        b1 = standardizing(g_b)
        image_show(r1, g1, b1, 'E:\Documents\python_work\dip\out\\blpf.jpg')
    elif k == 2:
        '''2为理想高通滤波'''
        g_r, g_g, g_b = hpf(50)
        r2 = standardizing(g_r)
        g2 = standardizing(g_g)
        b2 = standardizing(g_b)
        image_show(r2, g2, b2, 'E:\Documents\python_work\dip\out\\hpf.jpg')
    elif k == 3:
        '''3为巴特沃斯高通滤波'''
        g_r, g_g, g_b = bhpf(50, 3)
        r3 = standardizing(g_r)
        g3 = standardizing(g_g)
        b3 = standardizing(g_b)
        image_show(r3, g3, b3, 'E:\Documents\python_work\dip\out\\bhpf.jpg')
    elif k == 4:
        sys.exit()


if __name__ == '__main__':
    while 1:
        state = eval(init())
        switch(state)