图像处理之三种常见双立方插值算法

http://blog.csdn.net/jia20003/article/details/40020775

图像处理之三种常见双立方插值算法

双立方插值计算涉及到16个像素点，其中(i’, j’)表示待计算像素点在源图像中的包含

小数部分的像素坐标，dx表示X方向的小数坐标，dy表示Y方向的小数坐标。具体

可以看下图：

根据上述图示与双立方插值的数学表达式可以看出，双立方插值本质上图像16个像素点

权重卷积之和作为新的像素值。

其中R(x)表示插值表达式，可以根据需要选择的表达式不同。常见有基于三角取值、Bell

分布表达、B样条曲线表达式。

1. 基于三角形采样数学公式为

最简单的线性分布，代码实现如下：

[java] view plain copy

1. private double triangleInterpolation( double f )
2. {
3. f = f / 2.0;
4. if( f < 0.0 )
5. {
6. return ( f + 1.0 );
7. }
8. else
9. {
10. return ( 1.0 - f );
11. }
12. }

2.基于Bell分布采样的数学公式如下：

Bell分布采样数学公式基于三次卷积计算实现。代码实现如下：

[java] view plain copy

1. private double bellInterpolation( double x )
2. {
3. double f = ( x / 2.0 ) * 1.5;
4. if( f > -1.5 && f < -0.5 )
5. {
6. return( 0.5 * Math.pow(f + 1.5, 2.0));
7. }
8. else if( f > -0.5 && f < 0.5 )
9. {
10. return 3.0 / 4.0 - ( f * f );
11. }
12. else if( ( f > 0.5 && f < 1.5 ) )
13. {
14. return( 0.5 * Math.pow(f - 1.5, 2.0));
15. }
16. return 0.0;
17. }

3.基于B样条曲线采样的数学公式如下：

是一种基于多项式的四次卷积的采样计算，代码如下：

[java] view plain copy

1. private double bspLineInterpolation( double f )
2. {
3. if( f < 0.0 )
4. {
5. f = -f;
6. }
7. if( f >= 0.0 && f <= 1.0 )
8. {
9. return ( 2.0 / 3.0 ) + ( 0.5 ) * ( f* f * f ) - (f*f);
10. }
11. else if( f > 1.0 && f <= 2.0 )
12. {
13. return 1.0 / 6.0 * Math.pow( ( 2.0 - f  ), 3.0 );
14. }
15. return 1.0;
16. }

实现图像双立方插值的完整源代码如下：

[java] view plain copy

1. package com.gloomyfish.zoom.study;
2. import java.awt.image.BufferedImage;
3. import java.awt.image.ColorModel;
4. import com.gloomyfish.filter.study.AbstractBufferedImageOp;
5. public class BicubicInterpolationFilter extends AbstractBufferedImageOp  {
6. public final static int TRIANGLE__INTERPOLATION = 1;
7. public final static int BELL__INTERPOLATION = 2;
8. public final static int BSPLINE__INTERPOLATION = 4;
9. public final static int CATMULLROOM__INTERPOLATION = 8;
10. public final static double B = 0.0;
11. public final static double C = 0.5; // constant
12. private int destH; // zoom height
13. private int destW; // zoom width
14. private int type;
15. public BicubicInterpolationFilter()
16. {
17. this.type = BSPLINE__INTERPOLATION;
18. }
19. public void setType(int type) {
20. this.type = type;
21. }
22. public void setDestHeight(int destH) {
23. this.destH = destH;
24. }
25. public void setDestWidth(int destW) {
26. this.destW = destW;
27. }
28. private double bellInterpolation( double x )
29. {
30. double f = ( x / 2.0 ) * 1.5;
31. if( f > -1.5 && f < -0.5 )
32. {
33. return( 0.5 * Math.pow(f + 1.5, 2.0));
34. }
35. else if( f > -0.5 && f < 0.5 )
36. {
37. return 3.0 / 4.0 - ( f * f );
38. }
39. else if( ( f > 0.5 && f < 1.5 ) )
40. {
41. return( 0.5 * Math.pow(f - 1.5, 2.0));
42. }
43. return 0.0;
44. }
45. private double bspLineInterpolation( double f )
46. {
47. if( f < 0.0 )
48. {
49. f = -f;
50. }
51. if( f >= 0.0 && f <= 1.0 )
52. {
53. return ( 2.0 / 3.0 ) + ( 0.5 ) * ( f* f * f ) - (f*f);
54. }
55. else if( f > 1.0 && f <= 2.0 )
56. {
57. return 1.0 / 6.0 * Math.pow( ( 2.0 - f  ), 3.0 );
58. }
59. return 1.0;
60. }
61. private double triangleInterpolation( double f )
62. {
63. f = f / 2.0;
64. if( f < 0.0 )
65. {
66. return ( f + 1.0 );
67. }
68. else
69. {
70. return ( 1.0 - f );
71. }
72. }
73. private double CatMullRomInterpolation( double f )
74. {
75. if( f < 0.0 )
76. {
77. f = Math.abs(f);
78. }
79. if( f < 1.0 )
80. {
81. return ( ( 12 - 9 * B - 6 * C ) * ( f * f * f ) +
82. ( -18 + 12 * B + 6 *C ) * ( f * f ) +
83. ( 6 - 2 * B ) ) / 6.0;
84. }
85. else if( f >= 1.0 && f < 2.0 )
86. {
87. return ( ( -B - 6 * C ) * ( f * f * f )
88. + ( 6 * B + 30 * C ) * ( f *f ) +
89. ( - ( 12 * B ) - 48 * C  ) * f +
90. 8 * B + 24 * C)/ 6.0;
91. }
92. else
93. {
94. return 0.0;
95. }
96. }
97. @Override
98. public BufferedImage filter(BufferedImage src, BufferedImage dest) {
99. int width = src.getWidth();
100. int height = src.getHeight();
101. if (dest == null)
102. dest = createCompatibleDestImage(src, null);
103. int[] inPixels = new int[width * height];
104. int[] outPixels = new int[destH * destW];
105. getRGB(src, 0, 0, width, height, inPixels);
106. float rowRatio = ((float) height) / ((float) destH);
107. float colRatio = ((float) width) / ((float) destW);
108. int index = 0;
109. for (int row = 0; row < destH; row++) {
110. int ta = 0, tr = 0, tg = 0, tb = 0;
111. double srcRow = ((float) row) * rowRatio;
112. // 获取整数部分坐标 row Index
113. double j = Math.floor(srcRow);
114. // 获取行的小数部分坐标
115. double t = srcRow - j;
116. for (int col = 0; col < destW; col++) {
117. double srcCol = ((float) col) * colRatio;
118. // 获取整数部分坐标 column Index
119. double k = Math.floor(srcCol);
120. // 获取列的小数部分坐标
121. double u = srcCol - k;
122. double[] rgbData = new double[3];
123. double rgbCoffeData = 0.0;
124. for(int m=-1; m<3; m++)
125. {
126. for(int n=-1; n<3; n++)
127. {
128. int[] rgb = getPixel(j+m, k+n, width, height, inPixels);
129. double f1 = 0.0d;
130. double f2 = 0.0d;
131. if(type == TRIANGLE__INTERPOLATION)
132. {
133. f1  = triangleInterpolation( ((double) m ) - t );
134. f2 = triangleInterpolation ( -(( (double) n ) - u ) );
135. }
136. else if(type == BELL__INTERPOLATION)
137. {
138. f1  = bellInterpolation( ((double) m ) - t );
139. f2 = bellInterpolation ( -(( (double) n ) - u ) );
140. }
141. else if(type == BSPLINE__INTERPOLATION)
142. {
143. f1  = bspLineInterpolation( ((double) m ) - t );
144. f2 = bspLineInterpolation ( -(( (double) n ) - u ) );
145. }
146. else
147. {
148. f1  = CatMullRomInterpolation( ((double) m ) - t );
149. f2 = CatMullRomInterpolation ( -(( (double) n ) - u ) );
150. }
151. // sum of weight
152. rgbCoffeData += f2*f1;
153. // sum of the RGB values
154. rgbData[0] += rgb[0] * f2 * f1;
155. rgbData[1] += rgb[1] * f2 * f1;
156. rgbData[2] += rgb[2] * f2 * f1;
157. }
158. }
159. ta = 255;
160. // get Red/green/blue value for sample pixel
161. tr = (int) (rgbData[0]/rgbCoffeData);
162. tg = (int) (rgbData[1]/rgbCoffeData);
163. tb = (int) (rgbData[2]/rgbCoffeData);
164. index = row * destW + col;
165. outPixels[index] = (ta << 24) | (clamp(tr) << 16)
166. | (clamp(tg) << 8) | clamp(tb);
167. }
168. }
169. setRGB(dest, 0, 0, destW, destH, outPixels);
170. return dest;
171. }
172. public int clamp(int value) {
173. return value > 255 ? 255 :
174. (value < 0 ? 0 : value);
175. }
176. private int[] getPixel(double j, double k, int width, int height,
177. int[] inPixels) {
178. int row = (int) j;
179. int col = (int) k;
180. if (row >= height) {
181. row = height - 1;
182. }
183. if (row < 0) {
184. row = 0;
185. }
186. if (col < 0) {
187. col = 0;
188. }
189. if (col >= width) {
190. col = width - 1;
191. }
192. int index = row * width + col;
193. int[] rgb = new int[3];
194. rgb[0] = (inPixels[index] >> 16) & 0xff;
195. rgb[1] = (inPixels[index] >> 8) & 0xff;
196. rgb[2] = inPixels[index] & 0xff;
197. return rgb;
198. }
199. public BufferedImage createCompatibleDestImage(
200. BufferedImage src, ColorModel dstCM) {
201. if ( dstCM == null )
202. dstCM = src.getColorModel();
203. return new BufferedImage(dstCM,
204. dstCM.createCompatibleWritableRaster(destW, destH),
205. dstCM.isAlphaPremultiplied(), null);
206. }
207. }

运行效果：原图

双立方插值放大以后：

总结：

基于这里三种方法实现的双立方插值以后图片跟原图像相比，都有一定模糊

这里时候可以通过后续处理实现图像锐化与对比度提升即可得到Sharpen版本

当然也可以通过寻找更加合适的R(x)函数来实现双立方卷积插值过程时保留

图像边缘与对比度。