圖像處理之三種常見雙立方插值算法

時間  2019-12-14
標籤 圖像處理 三種 常見 立方 插值 算法 简体版
原文   原文鏈接

轉自：http://blog.csdn.net/jia20003/article/details/40020775java

 

圖像處理之三種常見雙立方插值算法算法

雙立方插值計算涉及到16個像素點，其中(i’, j’)表示待計算像素點在源圖像中的包含ide

小數部分的像素座標，dx表示X方向的小數座標，dy表示Y方向的小數座標。具體函數

能夠看下圖：this

根據上述圖示與雙立方插值的數學表達式能夠看出，雙立方插值本質上圖像16個像素點spa

權重卷積之和做爲新的像素值。.net

其中R(x)表示插值表達式，能夠根據須要選擇的表達式不一樣。常見有基於三角取值、Bellblog

分佈表達、B樣條曲線表達式。圖片

1. 基於三角形採樣數學公式爲ip

最簡單的線性分佈，代碼實現以下：

 

[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)函數來實現雙立方卷積插值過程時保留

圖像邊緣與對比度。

轉載請務必註明

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程