中值滤波的代码实现

冷不防 2022-11-12 00:43 203阅读 0赞

## 二值图片处理 ##

无论是平均平滑还是高斯平滑，在处理图像噪声时，都或多或少会对图片产生一定的模糊，损失部分信息。较为理想的情况，是可以选择性地进行滤波，只在噪声区域进行平滑，而在无噪声区域不进行平滑，将模糊的影响降到最低，这就是自适应性滤波的思想。通常噪声的存在，可能会使得附近邻域内，极值的上下差距较大，或者是方差较大，我们可以设置一定的阈值来判断该点是否需要进行平滑。不过这个不是该章节的内容，这一章是要学习中值滤波，中值滤波本质上是一个统计排序滤波器，是以该点为中心的的邻域内的所有像素的统计排序中值作为该点的响应；而平滑就是加权平均数作为响应，概念上有一定差别。

不同的滤波器在处理不同类型的噪声是效果不同，对于线性平滑滤波，在处理像素邻域内的噪声点时，噪
       声或多或少都会影响该点的像素值计算(以高斯平滑为例，距离近则影响大，距离远则影响小，与距离的
       平方呈反比)；但是中值滤波通常可以将噪声点直接忽略掉。同时，中值滤波在降噪的同时引起的模糊效
       应较低。中值滤波的一种典型应用，就是用来消除椒盐(salt & pepper)噪声。于是我们先编写一个函数来
       为我们的灰度图像添加椒盐噪声。

from PIL import Image
    import numpy as np
     
    def AddNoise(src, dst, probility = 0.05, method = "salt_pepper"):
     
    	imarray = np.array(Image.open(src))
    	height, width = imarray.shape
     
    	for i in range(height):
    		for j in range(width):
    			if np.random.random(1) < probility:
    				if np.random.random(1) < 0.5:
    					imarray[i, j] = 0
    				else:
    					imarray[i, j] = 255
    	new_im = Image.fromarray(imarray)
    	new_im.save(dst)
     
    gray_girl = "C:/Users/60214/Desktop/python_work/DigitalExecution/gray_girl.jpg"
    tar = "C:/Users/60214/Desktop/python_work/DigitalExecution/gray_girl_saltpepper.jpg"
     
    AddNoise(gray_girl, tar)

处理之后的图像如下，这就是椒盐噪声。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70]

使用平均模板处理之后的图像如下，图片变模糊的同时并没有消除椒盐噪声。虽然没有摆图，但是如果
         使用高斯平滑，也是同样的效果，椒盐噪声的影响依旧存在。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 1]

使用一个3x3尺寸的中值滤波来处理含有突发性的椒盐噪声的代码如下。其中我们选择的填充方式是无
          填充，也就是对图像边缘，上下左右处忽略掉不进行滤波，只对可以容纳下一个滤波模板的区域滤波。
          这样子的做法好处是代码编写起来比较简单，而一般情况下图像边缘出的信息不是那么重要所以这样子
          做的风险比较小。另外，执行寻找中值的用numpy自带的median方法，我们也可以自己写一个排序算法
          来执行。

from PIL import Image
    import numpy as np
     
    def MedianFilter(src, dst, k = 3, padding = None):
     
    	imarray = np.array(Image.open(src))
    	height, width = imarray.shape
     
    	if not padding:
    		edge = int((k-1)/2)
    		if height - 1 - edge <= edge or width - 1 - edge <= edge:
    			print("The parameter k is to large.")
    			return None
    		new_arr = np.zeros((height, width), dtype = "uint8")
    		for i in range(height):
    			for j in range(width):
    				if i <= edge - 1 or i >= height - 1 - edge or j <= edge - 1 or j >= height - edge - 1:
    					new_arr[i, j] = imarray[i, j]
    				else:
    					new_arr[i, j] = np.median(imarray[i - edge:i + edge + 1, j - edge:j + edge + 1])
    		new_im = Image.fromarray(new_arr)
    		new_im.save(dst)
     
    src = "C:/Users/60214/Desktop/python_work/DigitalExecution/gray_girl_saltpepper.jpg"
    dst = "C:/Users/60214/Desktop/python_work/DigitalExecution/aaa.jpg"
     
    MedianFilter(src, dst)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 2]

代码运行的结果是得到一张处理后的图像，如上图所示。可以看到确实把绝大部分的椒盐点都去除了，除
       了在边缘上一个像素宽度的区域有一些零星的点。但是，跟其他平滑的结果类似的，中值滤波也使得图像
       的清晰度有所下降。这是因为在处理一些边缘的时候也采用了中值滤波，导致了清晰度的下降。所以如果
       要解决这个问题，可以在对像素点赋予邻域的中位数之前添加一个判断条件。因为我们知道，噪声，往往
       都是数值与附近的区域相差很大，接近0或者是255，也就是很大可能是附近邻域内的极值。所以我们的判
       断条件就是，该像素是否是滤波窗口覆盖下邻域的极大值或极小值，如果是就进行中值滤波；如果不是就
       不予处理。修改后的新的代码为

from PIL import Image
    import numpy as np
     
    def BetterMedianFilter(src, dst, k = 3, padding = None):
     
    	imarray = np.array(Image.open(src))
    	height, width = imarray.shape
     
    	if not padding:
    		edge = int((k-1)/2)
    		if height - 1 - edge <= edge or width - 1 - edge <= edge:
    			print("The parameter k is to large.")
    			return None
    		new_arr = np.zeros((height, width), dtype = "uint8")
    		for i in range(height):
    			for j in range(width):
    				if i <= edge - 1 or i >= height - 1 - edge or j <= edge - 1 or j >= height - edge - 1:
    					new_arr[i, j] = imarray[i, j]
    				else:
    					#nm:neighbour matrix
    					nm = imarray[i - edge:i + edge + 1, j - edge:j + edge + 1]
    					max = np.max(nm)
    					min = np.min(nm)
    					if imarray[i, j] == max or imarray[i, j] == min:
    						new_arr[i, j] = np.median(nm)
    					else:
    						new_arr[i, j] = imarray[i, j]
    		new_im = Image.fromarray(new_arr)
    		new_im.save(dst)
     
    src = "C:/Users/60214/Desktop/python_work/DigitalExecution/gray_girl_saltpepper.jpg"
    dst = "C:/Users/60214/Desktop/python_work/DigitalExecution/aaaa.jpg"
    MedianFilter(src, dst)

下图是k=3是的改进后的中值滤波策略的结果，可以看到图像的清晰度得到了较大的保留，噪声的数量就
       相对也残留的比较多。从中可以看到，二者之间有此消彼长的关系。至于为什么还有这么多的椒盐噪声，
       原因是因为我们添加噪声的代码中设置的概率太高了，导致图像中的椒盐噪声数量非常多，在小区域内有
       可能有许多的噪声点，导致算法所寻找到的中值仍然是噪声的数值范围。这种情况下扩大滤波模板的大小
       并不会有多大的改变。此时可以将已经执行过一次中值滤波的结果图像再执行一次中值滤波，效果就会更
       好一些。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 3]  
执行了一次改良过的中值滤波的结果

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 4]  
转载于：[https://blog.csdn.net/baidu\_41902768/article/details/94451787][https_blog.csdn.net_baidu_41902768_article_details_94451787]

执行了两次改良过的中值滤波的结果

## 三通道图片处理 ##

中值滤波的原理：

中值滤波，其原理在于使用卷积核内的中值来代替中心点的值。例如，当一个点值为255时，而周围其他点全都低于120，这时候它就是一个明显的噪点。使用中值滤波时，就会用其他的点代替该点的值。不敢说替换的点就是真值，但是它一定比原来的点更接近真值。

下面将介绍如何使用python代码来实现。（文中所使用的图像为网图，如有侵权请及时联系删除）

from PIL import Image
    import numpy as np
    class Mdiean_Filter:
         def __init__(self, source_img):
             self.source_img = source_img   #原图
             self.noise_img = './salt_noise.jpg' #加了椒盐噪声之后的图像
             self.mdiean_img = './mdiean_filter.jpg' #中值滤波的图像
             self.k = 3
         def Add_Salt_Noise(self): # 加椒盐噪声
             img = Image.open(self.source_img)
             imgarray = np.array(img)
             height,width = imgarray.shape[0], imgarray.shape[1]
             for i in range(height):
                 for j in range(width):
                     if np.random.random(1) < 0.05:
                         if np.random.random(1) < 0.3:
                             imgarray[i][j] = 0
                         else:
                             imgarray[i][j] = 255
             new_img = Image.fromarray(imgarray)
             new_img.save(self.noise_img)
             return imgarray
         def Mdiean_Filtering(self, padding = None): #中值滤波会变为二值图
             img = Image.open(self.noise_img)
             imgarray = np.array(img)
             height, width = imgarray.shape[0], imgarray.shape[1]
             print(imgarray.shape)
             if not padding:
                 edge = int((self.k -1)/2)
                 if height -1 -edge <=edge or width -1-edge<=edge:
                     print("the kenerl is to long")
                     return  None
                 new_arr = np.zeros((height, width,3), dtype='uint8')
                 print(new_arr.shape)
                 for i in range(height):
                     for j in range(width):
                         if i <=edge -1 or i >= height -1 -edge or  j <=edge -1 or j >= height -1 -edge:
                             new_arr[i, j] = imgarray[i, j]
                         else:
                             new_arr[i, j] = np.median(imgarray[i - edge:i + edge + 1, j -edge:j+edge + 1]) #numpy的代码计算时会把矩阵三个数值变成一样，这也是色彩损失的原因
                 new_img = Image.fromarray(new_arr)
                 new_img.save(self.mdiean_img)
    
         def Mdiean_Filter1(self, padding = None): #中值滤波不损失色彩
    
             imgarray = self.Add_Salt_Noise()
             height, width = imgarray.shape[0], imgarray.shape[1]
    
             if not padding:
                 edge = int((self.k -1)/2)
                 if height -1 -edge <=edge or width -1-edge<=edge:
                     print("the kenerl is to long")
                     return  None
                 for i in range(height):
                     for j in range(width):
                         if i <=edge -1 or i >= height -1 -edge or  j <=edge -1 or j >= height -1 -edge:
                             imgarray[i][j] = imgarray[i][j]
                         else:
    
                             num = []
                             for m in range(i - edge, i + edge + 1):
                                 for n in range(j -edge, j+edge + 1):
                                     num.append((imgarray[m][n])[0]) #这里通过彩色图像第一个值计算中值也可以改为第二个或者第三个
                             temp = np.median(num)
                             idex_tem = num.index(temp)  #获取中值在数组中的坐标
                             l1 = int((idex_tem / self.k ))- edge + i #根据进制转换反推出中值在图像中的坐标
                             l2 = (idex_tem % self.k )- edge + j
                             print(imgarray[l1][l2])
                             imgarray[i][j] = imgarray[l1][l2] #赋值
                             #num1 = np.sort(num)[int(self.k * self.k / 2)]
                             #print(idex_tem)
                             #temp = np.median(imgarray[i][j], imgarray[i - edge][j], imgarray[i - edge][j])
                             #imgarray[i][j] = np.median(imgarray[i - edge:i + edge + 1, j -edge:j+edge + 1])
    
                 new_img = Image.fromarray(imgarray)
                 new_img.save(self.mdiean_img)
    if __name__=="__main__":
        example = 'example.jpg'
        filter = Mdiean_Filter(example)
        #filter.Add_Salt_Noise()
        filter.Mdiean_Filter1()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 5]  
转载于：[https://www.pianshen.com/article/66921359095/][https_www.pianshen.com_article_66921359095]

#### 代码注解： ####

#### 1.基本功能 ####

**\#初始化具有三种功能的对象  
lter = Mdiean\_Filter(example)  
\#加椒盐噪点  
filter.Add\_Salt\_Noise()  
\#二值图片中值滤波  
filter.Mdiean\_Filter()  
\#三通道图片中值滤波  
filter.Mdiean\_Filter1()**

**2.  
在两种中值滤波方法中都是用的是含有椒盐噪点的图片，为了反映效果**

imgarray = self.Add_Salt_Noise()
     height, width = imgarray.shape[0], imgarray.shape[1]

**但是我们直接使用在原图上既可，将代码改至如下：**

img = Image.open(self.source_img)
    imgarray = np.array(img)
    height, width = imgarray.shape[0], imgarray.shape[1]
    if __name__=="__main__":
        example = "G:/soft/img_done.png"
        filter = Mdiean_Filter(example)
        filter.Mdiean_Filter1()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70]: /images/20221022/6b4b1d0747394503a7533c7b3078ae1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 1]: /images/20221022/af19dee57cb9451fb876f2943ea4fd37.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210321170203611.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210321170220870.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210321170305412.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U=,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_baidu_41902768_article_details_94451787]: https://blog.csdn.net/baidu_41902768/article/details/94451787
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210321170547827.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvY2tob3U=,size_16,color_FFFFFF,t_70
[https_www.pianshen.com_article_66921359095]: https://www.pianshen.com/article/66921359095/