基础知识

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

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).

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

一、问题分析

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

二、结果图

原图

算术均值图

几何均值图

谐波均值滤波均值图

三、代码附录

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")
        
 

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

一、问题分析

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

二、结果图

左边为原图，右边为经过处理后的效果图

三、代码

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环境下如何用滤波器（/逆滤波/均值滤波/低通滤波/高通滤波）处理图片【附代码】基础知识应用一：算术均值、几何均值、谐波逆谐波应用二：维纳滤波，逆滤波相关链接的全部内容，希望文章能够帮你解决图像处理/计算机视觉/ python环境下如何用滤波器（/逆滤波/均值滤波/低通滤波/高通滤波）处理图片【附代码】基础知识应用一：算术均值、几何均值、谐波逆谐波应用二：维纳滤波，逆滤波相关链接所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。