均值滤波

Posted 2023-04-09

参考技术A   均值滤波是指用当前像素点周围N·N个像素值的均值来代替当前像素值。使用该方法遍历处理图像内的每一个像素点，即可完成整幅图像的均值滤波。

例如，希望对图7-7中位于第5行第5列的像素点进行均值滤波。

根据上述运算，针对每一个像素点，都是与一个内部值均为1/25的5×5矩阵相乘，得到均值滤波的计算结果，如图7-11所示。

将使用的5×5矩阵一般化，可以得到如图7-12所示的结果。

式中，M和N分别对应高度和宽度。一般情况下，M和N是相等的，例如比较常用的3×3、5×5、7×7等。如果M和N的值越大，参与运算的像素点数量就越多，图像失真越严重。

在OpenCV中，实现均值滤波的函数是cv2.blur()，其语法格式为：

式中：

通常情况下，使用均值滤波函数时，对于锚点anchor和边界样式borderType，直接采用其默认值即可。

【例7.2】针对噪声图像，使用不同大小的卷积核对其进行均值滤波，并显示均值滤波的情况。

  从图中可以看出，使用5×5的卷积核进行滤波处理时，图像的失真不明显；而使用30×30的卷积核进行滤波处理时，图像的失真情况较明显。
  卷积核越大，参与到均值运算中的像素就会越多，即当前点计算的是更多点的像素值的平均值。因此，卷积核越大，去噪效果越好，当然花费的计算时间也会越长，同时让图像失真越严重。在实际处理中，要在失真和去噪效果之间取得平衡，选取合适大小的卷积核。

均值滤波，中值滤波，最大最小值滤波

http://blog.csdn.net/fastbox/article/details/7984721

讨论如何使用卷积作为数学工具来处理图像，实现图像的滤波，其方法包含以下几种，均值

滤波，中值滤波，最大最小值滤波，关于什么是卷积以及理解卷积在图像处理中作用参见这

里–http://blog.csdn.net/jia20003/article/details/7038938

 

均值滤波：

均值滤波，是图像处理中最常用的手段，从频率域观点来看均值滤波是一种低通滤波器，高

频信号将会去掉，因此可以帮助消除图像尖锐噪声，实现图像平滑，模糊等功能。理想的均

值滤波是用每个像素和它周围像素计算出来的平均值替换图像中每个像素。采样Kernel数

据通常是3X3的矩阵，如下表示：

从左到右从上到下计算图像中的每个像素，最终得到处理后的图像。均值滤波可以加上两个

参数，即迭代次数，Kernel数据大小。一个相同的Kernel，但是多次迭代就会效果越来越好。

同样，迭代次数相同，Kernel矩阵越大，均值滤波的效果就越明显。

 

中值滤波

中值滤波也是消除图像噪声最常见的手段之一，特别是消除椒盐噪声，中值滤波的效果要比

均值滤波更好。中值滤波是跟均值滤波唯一不同是，不是用均值来替换中心每个像素，而是

将周围像素和中心像素排序以后，取中值，一个3X3大小的中值滤波如下：

 

最大最小值滤波

最大最小值滤波是一种比较保守的图像处理手段，与中值滤波类似，首先要排序周围像素和

中心像素值，然后将中心像素值与最小和最大像素值比较，如果比最小值小，则替换中心像

素为最小值，如果中心像素比最大值大，则替换中心像素为最大值。一个Kernel矩阵为3X3的最大最小值滤波如下：

 

 原图如下：

 

分别实现中值和均值滤波以后效果如下：

代码就不解释了，原理已经解释得很清楚了，全部算法源代码都是基于Java

特别说明一点的是，均值滤波对于高斯噪声的效果比较好，中值滤波对于椒盐噪声的效果比较好

想必大家从上面效果比较中也可以看到一点端倪。因为我选择的噪声图片是椒盐噪声的，哈哈

 

自己读吧，不解释了，有问题的可以问，源代码如下：

 

[java] view plaincopy

 

1. package com.process.blur.study;  
2.   
3. import java.awt.image.BufferedImage;  
4. import java.util.ArrayList;  
5. import java.util.Arrays;  
6.   
7.   
8. public class SmoothFilter extends AbstractBufferedImageOp {  
9.     public final static int MEAN_FILTER_TYPE = 1;  
10.     public final static int MEADIAN_FILTER_TYPE = 2;  
11.     public final static int MIN_MAX_FILTER_TYPE = 4;  
12.       
13.     private int repeats = 3; // default 1   
14.     private int kernel_size = 3; // default 3   
15.     private int type = 1; // default mean type   
16.       
17.     public int getRepeat() {  
18.         return repeats;  
19.     }  
20.       
21.     public void setRepeat(int repeat) {  
22.         this.repeats = repeat;  
23.     }  
24.       
25.     public int getKernelSize() {  
26.         return kernel_size;  
27.     }  
28.       
29.     public void setKernelSize(int kernelSize) {  
30.         this.kernel_size = kernelSize;  
31.     }  
32.       
33.     public int getType() {  
34.         return type;  
35.     }  
36.       
37.     public void setType(int type) {  
38.         this.type = type;  
39.     }  
40.   
41.     @Override  
42.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
43.         int width = src.getWidth();  
44.         int height = src.getHeight();  
45.   
46.         if ( dest == null )  
47.             dest = createCompatibleDestImage( src, null );  
48.           
49.         int[] inPixels = new int[width*height];  
50.         int[] outPixels = new int[width*height];  
51.         getRGB( src, 0, 0, width, height, inPixels );  
52.           
53.         // pick up one filter from here!!!   
54.         if(this.type == MEAN_FILTER_TYPE)   
55.         {  
56.             for(int i=0; i<repeats; i++) {  
57.                 performMeanFilter(width, height, inPixels, outPixels);  
58.                 System.arraycopy(outPixels, 0, inPixels, 0, inPixels.length);  
59.             }  
60.         }   
61.         else if(this.type == MEADIAN_FILTER_TYPE)   
62.         {  
63.             performMedianFilter(width, height, inPixels, outPixels);  
64.         }   
65.         else if(this.type == MIN_MAX_FILTER_TYPE)   
66.         {  
67.             performMinMaxFilter(width, height, inPixels, outPixels);  
68.         }  
69.           
70.         // return result   
71.         setRGB( dest, 0, 0, width, height, outPixels );  
72.         return dest;  
73.     }  
74.       
75.     /** 
76.      *  <p> perform convolution filter </p> 
77.      *  
78.      * @param width 
79.      * @param height 
80.      * @param inPixels 
81.      * @param outPixels 
82.      */  
83.     public void performMeanFilter(int width, int height, int[] inPixels, int[] outPixels) {  
84.   
85.         int rows2 = kernel_size/2;  
86.         int cols2 = kernel_size/2;  
87.         int index = 0;  
88.         int index2 = 0;  
89.         float total = kernel_size * kernel_size;  
90.         for (int y = 0; y < height; y++) {  
91.             for (int x = 0; x < width; x++) {  
92.                 float r = 0, g = 0, b = 0, a = 0;  
93.                 for (int row = -rows2; row <= rows2; row++) {  
94.                     int rowoffset = y + row;  
95.                     if(rowoffset < 0 || rowoffset >=height) {  
96.                         rowoffset = y;  
97.                     }  
98.                     //System.out.println("rowoffset == " + rowoffset);   
99.                     for(int col = -cols2; col <= cols2; col++) {  
100.                         int coloffset = col + x;  
101.                         if(coloffset < 0 || coloffset >= width) {  
102.                             coloffset = x;  
103.                         }  
104.                         index2 = rowoffset * width + coloffset;  
105.                         int rgb = inPixels[index2];  
106.                         a += ((rgb >> 24) & 0xff);  
107.                         r += ((rgb >> 16) & 0xff);  
108.                         g += ((rgb >> 8) & 0xff);  
109.                         b += (rgb & 0xff);  
110.                     }  
111.                 }  
112.                 int ia = 0xff;  
113.                 int ir = clamp((int)(r/total));  
114.                 int ig = clamp((int)(g/total));  
115.                 int ib = clamp((int)(b/total));  
116.                 outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;  
117.             }  
118.         }  
119.     }  
120.     /** 
121.      *  <p> perform median filter </p> 
122.      *  
123.      * @param width 
124.      * @param height 
125.      * @param src 
126.      * @param inPixels 
127.      * @param outPixels 
128.      */  
129.     public void performMedianFilter(int width, int height, int[] inPixels, int[] outPixels) {  
130.   
131.         int rows2 = kernel_size/2;  
132.         int cols2 = kernel_size/2;  
133.         int index = 0;  
134.         int index2 = 0;  
135.         float total = kernel_size * kernel_size;  
136.         int[] matrix = new int[(int)total];  
137.         for (int y = 0; y < height; y++) {  
138.             for (int x = 0; x < width; x++) {  
139.                 int count = 0;  
140.                 for (int row = -rows2; row <= rows2; row++) {  
141.                     int rowoffset = y + row;  
142.                     if(rowoffset < 0 || rowoffset >=height) {  
143.                         rowoffset = y;  
144.                     }  
145.   
146.                     for(int col = -cols2; col <= cols2; col++) {  
147.                         int coloffset = col + x;  
148.                         if(coloffset < 0 || coloffset >= width) {  
149.                             coloffset = x;  
150.                         }  
151.                         index2 = rowoffset * width + coloffset;  
152.                         int rgb = inPixels[index2];  
153.                         matrix[count] = rgb;  
154.                         count++;   
155.                     }  
156.                 }  
157.                 Arrays.sort(matrix);  
158.                   
159.                 int ia = 0xff;  
160.                 int ir = ((matrix[count/2] >> 16) & 0xff);  
161.                 int ig = ((matrix[count/2] >> 8) & 0xff);  
162.                 int ib = (matrix[count/2] & 0xff);  
163.                 outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;  
164.             }  
165.         }  
166.     }  
167.       
168.     /** 
169.      * <p> perform min/max pixel filter </p> 
170.      *  
171.      * @param width 
172.      * @param height 
173.      * @param src 
174.      * @param inPixels 
175.      * @param outPixels 
176.      */  
177.     public void performMinMaxFilter(int width, int height, int[] inPixels, int[] outPixels) {  
178.         int rows2 = kernel_size/2;  
179.         int cols2 = kernel_size/2;  
180.         int index = 0;  
181.         int index2 = 0;  
182.         float total = kernel_size * kernel_size;  
183.         int[] matrix = new int[(int)total];  
184.         for (int y = 0; y < height; y++) {  
185.             for (int x = 0; x < width; x++) {  
186.                 int count = 0;  
187.                 for (int row = -rows2; row <= rows2; row++) {  
188.                     int rowoffset = y + row;  
189.                     if(rowoffset < 0 || rowoffset >=height) {  
190.                         rowoffset = y;  
191.                     }  
192.   
193.                     for(int col = -cols2; col <= cols2; col++) {  
194.                         int coloffset = col + x;  
195.                         if(coloffset < 0 || coloffset >= width) {  
196.                             coloffset = x;  
197.                         }  
198.                         index2 = rowoffset * width + coloffset;  
199.                         int rgb = inPixels[index2];  
200.                         matrix[count] = rgb;  
201.                         count++;   
202.                     }  
203.                 }  
204.                 int ia = 0xff;  
205.                 int oldPixel = matrix[count/2];  
206.                 int targetRGB = findNewPixel(matrix, oldPixel);  
207.                 int ir = ((targetRGB >> 16) & 0xff);  
208.                 int ig = ((targetRGB >> 8) & 0xff);  
209.                 int ib = (targetRGB & 0xff);  
210.                 outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;  
211.             }  
212.         }  
213.     }  
214.       
215.     private int findNewPixel(int[] matrix, int oldPixel) {  
216.         ArrayList<Integer> list = new ArrayList<Integer>();  
217.         for(int i=0; i<matrix.length; i++) {  
218.             if(matrix[i] == oldPixel)  
219.                 continue;  
220.             list.add(matrix[i]);  
221.         }  
222.         int[] filterData = new int[list.size()];  
223.         int index = 0;  
224.         for(Integer rgb : list) {  
225.             filterData[index++] = rgb;  
226.         }  
227.         Arrays.sort(filterData);  
228.           
229.         if(filterData.length == 0)  
230.             return oldPixel;  
231.         return (oldPixel > filterData[0]) ? filterData[0] : (oldPixel < filterData[filterData.length -1])? filterData[filterData.length -1] : oldPixel;  
232.     }  
233.   
234.     public static int clamp(int c) {  
235.         if (c < 0)  
236.             return 0;  
237.         if (c > 255)  
238.             return 255;  
239.         return c;  
240.     }  
241.   
242. }  

[java] view plain copy

 

1.