1. 首页
  2. 文章中心
  3. 人工智能

图像处理/计算机视觉/ python环境下如何用滤波器（/逆滤波/均值滤波/低通滤波/高通滤波）处理图片【附代码】基础知识应用一：算术均值、几何均值、谐波逆谐波应用二：维纳滤波，逆滤波相关链接

109 阅读 0 评论
我是靠谱客的博主 称心棉花糖，这篇文章主要介绍图像处理/计算机视觉/ python环境下如何用滤波器（/逆滤波/均值滤波/低通滤波/高通滤波）处理图片【附代码】基础知识应用一：算术均值、几何均值、谐波逆谐波应用二：维纳滤波，逆滤波相关链接，现在分享给大家，希望可以做个参考。

计算机视觉滤波器实操

  • 基础知识
    • 一、 计算机视觉技术中常见的几种滤波器
    • 二、滤波器相关知识
  • 应用一：算术均值、几何均值、谐波逆谐波
    • 一、问题分析
    • 二、结果图
    • 三、代码附录
  • 应用二：维纳滤波，逆滤波
    • 一、问题分析
    • 二、结果图
    • 三、代码
  • 相关链接

基础知识

一、 计算机视觉技术中常见的几种滤波器

1.理想的低通滤波器
其中，D0表示通带的半径。D(u,v)的计算方式也就是两点间的距离，很简单就能得到。
使用低通滤波器所得到的结果如下所示。低通滤波器滤除了高频成分，所以使得图像模糊。由于理想低通滤波器的过度特性过于急峻，所以会产生了振铃现象。

2.巴特沃斯低通滤波器
同样的，D0表示通带的半径，n表示的是巴特沃斯滤波器的次数。随着次数的增加，振铃现象会越来越明显。

3.高斯低通滤波器
D0表示通带的半径。高斯滤波器的过度特性非常平坦，因此是不会产生振铃现象的。
4.维纳滤波
5.算术均值滤波
6.几何均值滤波

二、滤波器相关知识

一、概述

1．定义
凡是可以使信号中特定的频率成分通过，而极大地衰减或抑制其他频率成分的装置或系统都称之为滤波器，相当于频率“筛子”。

2．分类
幅频特性如下
频率通带：能通过滤波器的频率范围
频率阻带：被滤波器抑制或极大地衰减的信号频率范围。
截止频率：通带与阻带的交界点。

2）按物理原理分：机械式、电路式

按处理信号分：模拟、数字

3．滤波器的作用
1）将有用的信号与噪声分离，提高信号的抗干扰性及信噪比；
2）滤掉不感兴趣的频率成分，提高分析精度；
3）从复杂频率成分中分离出单一的频率分量。

二、理想滤波器与实际滤波器

1．理想滤波器的频率特性
理想滤波器：使通带内信号的幅值和相位都不失真，阻喧内的频率成分都衰减为零的滤波器，其通带和阻带之间有明显的分界线。
如理想低通滤波器的频率响应函数为
理想滤波器实际上并不存在。

2．实际滤波器
实际滤波器的特性需要以下参数描述：
①信频程选择性：
与上、下截止频率处相比，频率变化一倍频程时幅频特性的衰减量，即
信频程选择性总是小于等于零，显然，计算信量的衰减量越大，选择性越好。
②滤波器因素 ：－60dB处的带宽与－3dB处的带宽之比值，即
③分辨力：即分离信号中相邻频率成分的能力，用品质因素Q描述。
3．实际带通滤波器的形式
①恒定带宽带通滤波器:B=常量，与中心频率f0无关。
②恒定百分比带通滤波器：
在高频区恒定百分比带通滤波器的分辨率比恒定带宽带通滤波器差。

三、RC无源模拟式滤波器

1．一阶RC低通滤波器
2．一阶高通滤波器
3．带通滤波器
将RC低通和高通滤波器串联起来，就可以组成RC带通滤波器。

四、数字滤波器简介
数学滤波：通过一定的计算方法和计算程序对离散信号进行加工，将其改造成新要求的。离散信号，有低通、高通、带通、带阻之分。数字滤波是对模拟滤波的一种模拟。如模拟RC低通滤波器。

更加详细的滤波器知识讲解可以参考我的另外一篇博客

链接: [(https://blog.csdn.net/champion564/article/details/124688761?spm=1001.2014.3001.5501).

应用一：算术均值、几何均值、谐波逆谐波

一、问题分析

使用算术均值滤波、几何均值滤波器、谐波滤波器、逆谐波滤波器处理图片，观察不同滤波器处理过后的图片。

二、结果图

原图
未处理原图片
算术均值图
在这里插入图片描述
几何均值图
在这里插入图片描述
谐波均值滤波均值图
在这里插入图片描述

三、代码附录

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
import numpy as np
import cv2
 
#算术均值滤波器：
def a_mean(img,kernel_size):
 
    G_mean_img = np.zeros(img.shape)
    #print(G_mean_img[0][0])
 
    #print(img)
    k = int((kernel_size-1)/2)
    #print(k)
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            if i <k or i>(img.shape[0]-k-1) or j <k or j>(img.shape[1]-k-1):
                G_mean_img[i][j]=img[i][j]
            else:
                for n in range(kernel_size):
                    for m in range(kernel_size):
                        G_mean_img[i][j] +=np.float(1/(kernel_size*kernel_size)*img[i-k+n][j-k+m])
 
 
                #G_mean_img[i][j]=1/9*(img[i-1][j-1]+img[i-1][j]+img[i-1][j+1]+img[i][j-1]+img[i][j]+img[i][j+1]+img[i+1][j-1]+img[i+1][j]+img[i+1][j+1])
    G_mean_img = np.uint8(G_mean_img)
    return G_mean_img
 
#几何均值滤波器：
def G_mean(img,kernel_size):
 
    G_mean_img = np.ones(img.shape)
    #print(G_mean_img[0][0])
 
    #print(img)
    k = int((kernel_size-1)/2)
    #print(k)
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            if i <k or i>(img.shape[0]-k-1) or j <k or j>(img.shape[1]-k-1):
                G_mean_img[i][j]=img[i][j]
            else:
                for n in range(kernel_size):
                    for m in range(kernel_size):
                        G_mean_img[i][j] *=np.float(img[i-k+n][j-k+m])
                G_mean_img[i][j] = pow(G_mean_img[i][j],1/(kernel_size*kernel_size))
 
 
                #G_mean_img[i][j]=1/9*(img[i-1][j-1]+img[i-1][j]+img[i-1][j+1]+img[i][j-1]+img[i][j]+img[i][j+1]+img[i+1][j-1]+img[i+1][j]+img[i+1][j+1])
    G_mean_img = np.uint8(G_mean_img)
    return G_mean_img
 
 
#谐波均值滤波均值滤波器：
def H_mean(img,kernel_size):
 
    G_mean_img = np.zeros(img.shape)
    #print(G_mean_img[0][0])
 
    #print(img)
    k = int((kernel_size-1)/2)
    #print(k)
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            if i <k or i>(img.shape[0]-k-1) or j <k or j>(img.shape[1]-k-1):
                G_mean_img[i][j]=img[i][j]
            else:
                for n in range(kernel_size):
                    for m in range(kernel_size):
                        if img[i-k+n][j-k+m] ==0:
                            G_mean_img[i][j] = 0
                            break
                        else:
                            G_mean_img[i][j] +=1/np.float(img[i-k+n][j-k+m])
                    else:
                        continue
                    break
                if G_mean_img[i][j]!=0:
                    G_mean_img[i][j] = (kernel_size*kernel_size)/G_mean_img[i][j]
 
 
                #G_mean_img[i][j]=1/9*(img[i-1][j-1]+img[i-1][j]+img[i-1][j+1]+img[i][j-1]+img[i][j]+img[i][j+1]+img[i+1][j-1]+img[i+1][j]+img[i+1][j+1])
    G_mean_img = np.uint8(G_mean_img)
    return G_mean_img
 
 
#逆谐波均值滤波均值滤波器：
def HT_mean(img,kernel_size,Q):
 
    G_mean_img = np.zeros(img.shape)
    #print(G_mean_img[0][0])
 
    #print(img)
    k = int((kernel_size-1)/2)
    #print(k)
 
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            if i <k or i>(img.shape[0]-k-1) or j <k or j>(img.shape[1]-k-1):
                G_mean_img[i][j]=img[i][j]
            else:
                result_top = 0
                result_down = 0
                for n in range(kernel_size):
                    for m in range(kernel_size):
                        if Q>0:
                            result_top +=pow(np.float(img[i-k+n][j-k+m]),Q+1)
                            result_down +=pow(np.float(img[i-k+n][j-k+m]),Q)
                        else:
                            if img[i-k+n][j-k+m]==0:
                                G_mean_img[i][j] = 0
                                break
                            else:
                                result_top +=pow(np.float(img[i-k+n][j-k+m]),Q+1)
                                result_down +=pow(np.float(img[i-k+n][j-k+m]),Q)
                    else:
                        continue
                    break
 
                else:
                    if result_down !=0:
                        G_mean_img[i][j] = result_top/result_down
 
 
                #G_mean_img[i][j]=1/9*(img[i-1][j-1]+img[i-1][j]+img[i-1][j+1]+img[i][j-1]+img[i][j]+img[i][j+1]+img[i+1][j-1]+img[i+1][j]+img[i+1][j+1])
    G_mean_img = np.uint8(G_mean_img)
    return G_mean_img
 
 
if __name__ == "__main__":
 
    img = cv2.imread('D:\01.JPG',0)
 
    G_mean_img_3 = HT_mean(img,kernel_size = 3,Q=-1.5)
    G_mean_img_5 = HT_mean(img,kernel_size = 5,Q=-1.5)
    G_mean_img_9 = HT_mean(img,kernel_size = 9,Q=-1.5)
                
    
    print(G_mean_img_3.max())
 
    cv2.imshow("show1",img)
    cv2.imshow("show2_3",G_mean_img_3)
    cv2.imshow("show3_5",G_mean_img_5)
    cv2.imshow("show3_9",G_mean_img_9)
    cv2.waitKey(0)
    
 
    print("test_end")

应用二：维纳滤波，逆滤波

一、问题分析

使用维纳滤波、逆滤波处理图片实现去雾效果，观察不同滤波器处理过后的图片。

二、结果图

左边为原图，右边为经过处理后的效果图
在这里插入图片描述

三、代码

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
import matplotlib.pyplot as graph
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(15):
            offset=round(i*slope_tan)    #((center_position-i)*slope_tan)
            PSF[int(center_position+offset),int(center_position-offset)]=1
        return PSF / PSF.sum()  #对点扩散函数进行归一化亮度
    else:
        for i in range(15):
            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.01):        #维纳滤波，K=0.01
    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
 
image = cv2.imread('C:/Users/admin/Desktop/OIP-C.jpg')
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
img_h=image.shape[0]
img_w=image.shape[1]
graph.figure(1)
graph.xlabel("Original Image")
graph.gray()
graph.imshow(image)     #显示原图像
 
graph.figure(2)
graph.gray()
#进行运动模糊处理
PSF = motion_process((img_h,img_w), 60)
blurred = np.abs(make_blurred(image, PSF, 1e-3))
 
graph.subplot(231)
graph.xlabel("Motion blurred")
graph.imshow(blurred)
 
result = inverse(blurred, PSF, 1e-3)   #逆滤波
graph.subplot(232)
graph.xlabel("inverse deblurred")
graph.imshow(result)
 
result=wiener(blurred,PSF,1e-3)     #维纳滤波
graph.subplot(233)
graph.xlabel("wiener deblurred(k=0.01)")
graph.imshow(result)
 
blurred_noisy=blurred + 0.1 * blurred.std() * 
           np.random.standard_normal(blurred.shape)   #添加噪声,standard_normal产生随机的函数
 
graph.subplot(234)
graph.xlabel("motion & noisy blurred")
graph.imshow(blurred_noisy)      #显示添加噪声且运动模糊的图像
 
result = inverse(blurred_noisy, PSF, 0.1+1e-3)    #对添加噪声的图像进行逆滤波
graph.subplot(235)
graph.xlabel("inverse deblurred")
graph.imshow(result)
 
result=wiener(blurred_noisy,PSF,0.1+1e-3)          #对添加噪声的图像进行维纳滤波
graph.subplot(236)
graph.xlabel("wiener deblurred(k=0.01)")
graph.imshow(result)
 
graph.show()

相关链接

图像处理之维纳滤波还原图像、直方图均值化【附代码、亲测有效】

图像处理之仿真运动模糊复原【使用逆滤波、维纳滤波】

图像处理/人工智能/opencv之深入理解模板匹配算法

图像处理/计算机视觉/python环境下如何用滤波器、算法恢复图片，对图片去污【附代码】

图像处理/计算机视觉/python环境下/机器学习 之k近邻方法（KNN）、模板匹配算法对数据集的识别

图像处理/计算机视觉/python环境下/如何用四种不同滤波器处理噪声【附代码、亲测有效】

更多关于计算机视觉、图像处理这方面的内容将持续更新。欢迎关注我的人工智能专栏。
如果以上内容对你有帮助，请点个赞吧。有任何问题和不明白的地方欢迎私信作者或者在评论区留言，谢谢。

最后

以上就是称心棉花糖最近收集整理的关于图像处理/计算机视觉/ python环境下如何用滤波器（/逆滤波/均值滤波/低通滤波/高通滤波）处理图片【附代码】基础知识应用一：算术均值、几何均值、谐波逆谐波应用二：维纳滤波，逆滤波相关链接的全部内容，更多相关图像处理/计算机视觉/内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(72)

相关文章

滤波器频率范围选择
滤波器频率范围选择
浅浅分析滤波器截止频率
浅浅分析滤波器截止频率
lc低通滤波器截止频率计算_LC滤波器简单介绍
lc低通滤波器截止频率计算_LC滤波器简单介绍
数字图像处理 高通滤波
数字图像处理 高通滤波
图像处理/计算机视觉/ python环境下如何用滤波器（/逆滤波/均值滤波/低通滤波/高通滤波）处理图片【附代码】基础知识应用一：算术均值、几何均值、谐波逆谐波应用二：维纳滤波，逆滤波相关链接
图像处理/计算机视觉/ python环境下如何用滤波器（/逆滤波/均值滤波/低通滤波/高通滤波）处理图片【附代码】基础知识应用一：算术均值、几何均值、谐波逆谐波应用二：维纳滤波，逆滤波相关链接
测试信号处理-模拟滤波器概述模拟滤波器概述
测试信号处理-模拟滤波器概述模拟滤波器概述
matlab如何实现隔直滤波器,matlab的滤波器仿真——低通滤波器与插值滤波器
matlab如何实现隔直滤波器,matlab的滤波器仿真——低通滤波器与插值滤波器
SystemView软件中“Butterworth Lowpass IIR“的完美设置一、存在问题二、解决办法三、拓展
SystemView软件中“Butterworth Lowpass IIR“的完美设置一、存在问题二、解决办法三、拓展

评论列表共有 0 条评论

立即
投稿
返回
顶部