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

特別說明一點的是，均值濾波對於高斯噪聲的效果比較好，中值濾波對於椒鹽噪聲的效果比較好

想必大家從上面效果比較中也可以看到一點端倪。因為我選擇的噪聲圖片是椒鹽噪聲的，哈哈

自己讀吧，不解釋了，有問題的可以問，源代碼如下：

1. package com.process.blur.study;
3. import java.awt.image.BufferedImage;
4. import java.util.ArrayList;
5. import java.util.Arrays;
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;
13. private int repeats = 3; // default 1
14. private int kernel_size = 3; // default 3
15. private int type = 1; // default mean type
17. public int getRepeat() {
18. return repeats;
19. }
21. public void setRepeat(int repeat) {
22. this.repeats = repeat;
23. }
25. public int getKernelSize() {
26. return kernel_size;
27. }
29. public void setKernelSize(int kernelSize) {
30. this.kernel_size = kernelSize;
31. }
33. public int getType() {
34. return type;
35. }
37. public void setType(int type) {
38. this.type = type;
39. }
41. @Override
42. public BufferedImage filter(BufferedImage src, BufferedImage dest) {
43. int width = src.getWidth();
44. int height = src.getHeight();
46. if ( dest == null )
47. dest = createCompatibleDestImage( src, null );
49. int[] inPixels = new int[width*height];
50. int[] outPixels = new int[width*height];
51. getRGB( src, 0, 0, width, height, inPixels );
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. }
70. // return result
71. setRGB( dest, 0, 0, width, height, outPixels );
72. return dest;
73. }
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) {
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) {
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. }
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);
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. }
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. }
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. }
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);
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. }
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. }
242. }

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