码迷，mamicode.com
首页 > 编程语言 > 详细

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

时间：2017-06-20 23:51:12      阅读：499      评论：0      收藏：0      [点我收藏+]

标签：blog   rgb   分布   pow   views   oat   tool   model   表达   

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.   
  8.     if( f >= 0.0 && f <= 1.0 )  
  9.     {  
  10.         return ( 2.0 / 3.0 ) + ( 0.5 ) * ( f* f * f ) - (f*f);  
  11.     }  
  12.     else if( f > 1.0 && f <= 2.0 )  
  13.     {  
  14.         return 1.0 / 6.0 * Math.pow( ( 2.0 - f  ), 3.0 );  
  15.     }  
  16.     return 1.0;  
  17. }  

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

 

 

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

运行效果：原图

 

技术分享

双立方插值放大以后：

技术分享
总结：

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

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

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

图像边缘与对比度。

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

标签：blog   rgb   分布   pow   views   oat   tool   model   表达   

原文地址：http://www.cnblogs.com/jukan/p/7056858.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！