备案控制台
探索云世界
开发者社区 人工智能 文章 正文

图像放缩------双立方插值

2015-07-24 1650
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： <p style="color: rgb(51, 51, 51); font-family: Arial; font-size: 14px; line-height: 26px;"><strong>一：数学原理</strong></p><p style="color: rgb(51, 51, 51); font-family: Arial; font-size: 14px; line-hei

一：数学原理

如果已知一个函数f(x)以及它在x=0,x=1处的导数，那么函数可以在[0,1]之间插值，当函数

表达为三次多项式时我们称之谓立方插值。一个三次多项式及其导数：

        f(x) =ax^3 +bx^2 + cx + d

         f’(x)=3ax^2 + 2bx +c

多项式在x=0, x=1处值及其导数值为：

         f(0)= d;

         f(1)= a + b + c + d;

         f’(0)=c

         f’(1)=3a + 2b + c

 

上述的四个等式可以等价的变换为:

         a= 2f(0) – 2f(1) + f’(0) + f’(1)

         b= -3f(0) + 3f(1) – 2f’(0) – f’(1)

         c= f’(0)

         d= f’(1)

假设你有四个点值p0, p1, p2, p3分别在x=-1, x=0, x=1, x=2, 把值分别指定到f(0), f(1), f’(0),

f’(1)中为:

         f(0)= p1

         f(1)= p2

         f’(0)= (p2 – p0)/2

         f’(1)= (p3-p1)/2

 

这个我们的立方插值公式变成:

f(p0,p1,p2,p3, x) = (-1/2p0 + 3/2p1 -3/2p2+ 1/2p3)x^3 + (p0-5/2p1 + 2p2 -1/2d)x^2 + (-1/2p0 +

1/2p2)x + p1

 

双立方插值是立方插值在二维空间的表达, 插值公式可以表述为:

G(x, y) = f (f (p00, p01, p02, p03, y), f(p10,p11, p12, p13, y), f(p20, p21, p22, p23, y), f(p30, p31, p32, p33, y), x)

解出其中的16个参数，即可得带G(x, y)目标插值点的值。

 

二：双立方插值优缺点

双立方插值在图像放大过程可以保留更多的图像细节，放大以后的图像带有反锯齿的功能，

同时图像和源图像相比效果更加真实, 缺点是计算量比较大，是常见的三种图像放大算法中

计算量最大的一种，据说Photoshop的图像放大就是基本双立方插值的优化算法


三：程序运行效果如下：


四：关键代码解析

不想解释太多，最重要的是代入计算的是浮点数坐标的小数部分，即 x, y的取值范围均在[0,1]之间


五：基于Java的程序完全源代码

[java]  view plain copy
  1. public class BiCubicInterpolationScale implements ImageScale {  
  2.   
  3.     private double a00, a01, a02, a03;  
  4.     private double a10, a11, a12, a13;  
  5.     private double a20, a21, a22, a23;  
  6.     private double a30, a31, a32, a33;  
  7.     private int srcWidth;  
  8.     private int srcHeight;  
  9.       
  10.     @Override  
  11.     public int[] imgScale(int[] inPixelsData, int srcW, int srcH, int destW, int destH) {  
  12.         double[][][] input3DData = processOneToThreeDeminsion(inPixelsData, srcH, srcW);  
  13.         int[][][] outputThreeDeminsionData = new int[destH][destW][4];  
  14.         double[][] tempPixels = new double[4][4];  
  15.         float rowRatio = ((float)srcH)/((float)destH);  
  16.         float colRatio = ((float)srcW)/((float)destW);  
  17.         this.srcWidth = srcW;  
  18.         this.srcHeight = srcH;  
  19.         for(int row=0; row<destH; row++) {  
  20.             // convert to three dimension data  
  21.             double srcRow = ((float)row)*rowRatio;  
  22.             double j = Math.floor(srcRow);  
  23.             double t = srcRow - j;  
  24.             for(int col=0; col<destW; col++) {  
  25.                 double srcCol = ((float)col)*colRatio;  
  26.                 double k = Math.floor(srcCol);  
  27.                 double u = srcCol - k;  
  28.                 for(int i=0; i<4; i++) {  
  29.                     tempPixels[0][0] = getRGBValue(input3DData,j-1, k-1,i);  
  30.                     tempPixels[0][1] = getRGBValue(input3DData,j-1, k, i);  
  31.                     tempPixels[0][2] = getRGBValue(input3DData, j-1,k+1, i);  
  32.                     tempPixels[0][3] = getRGBValue(input3DData, j-1, k+2,i);  
  33.                       
  34.                     tempPixels[1][0] = getRGBValue(input3DData, j, k-1, i);  
  35.                     tempPixels[1][1] = getRGBValue(input3DData, j, k, i);  
  36.                     tempPixels[1][2] = getRGBValue(input3DData, j, k+1, i);  
  37.                     tempPixels[1][3] = getRGBValue(input3DData, j, k+2, i);  
  38.                       
  39.                     tempPixels[2][0] = getRGBValue(input3DData, j+1,k-1,i);  
  40.                     tempPixels[2][1] = getRGBValue(input3DData, j+1, k, i);  
  41.                     tempPixels[2][2] = getRGBValue(input3DData, j+1, k+1, i);  
  42.                     tempPixels[2][3] = getRGBValue(input3DData, j+1, k+2, i);  
  43.                       
  44.                     tempPixels[3][0] = getRGBValue(input3DData, j+2, k-1, i);  
  45.                     tempPixels[3][1] = getRGBValue(input3DData, j+2, k, i);  
  46.                     tempPixels[3][2] = getRGBValue(input3DData, j+2, k+1, i);  
  47.                     tempPixels[3][3] = getRGBValue(input3DData, j+2, k+2, i);  
  48.                       
  49.                     // update coefficients  
  50.                     updateCoefficients(tempPixels);  
  51.                     outputThreeDeminsionData[row][col][i] = getPixelValue(getValue(t, u));  
  52.                 }  
  53.   
  54.             }  
  55.         }  
  56.           
  57.         return convertToOneDim(outputThreeDeminsionData, destW, destH);  
  58.     }  
  59.       
  60.     public double getRGBValue(double[][][] input3DData, double row, double col, int index) {  
  61.         if(col >= srcWidth) {  
  62.             col = srcWidth - 1;  
  63.         }  
  64.           
  65.         if(col < 0) {  
  66.             col = 0;  
  67.         }  
  68.           
  69.         if(row >= srcHeight) {  
  70.             row = srcHeight - 1;  
  71.         }  
  72.           
  73.         if(row < 0) {  
  74.             row = 0;  
  75.         }  
  76.         return input3DData[(int)row][(int)col][index];  
  77.     }  
  78.       
  79.     public int getPixelValue(double pixelValue) {  
  80.         return pixelValue < 0 ? 0: pixelValue >255.0d ?255:(int)pixelValue;  
  81.     }  
  82.       
  83.     public void updateCoefficients (double[][] p) {  
  84.         a00 = p[1][1];  
  85.         a01 = -.5*p[1][0] + .5*p[1][2];  
  86.         a02 = p[1][0] - 2.5*p[1][1] + 2*p[1][2] - .5*p[1][3];  
  87.         a03 = -.5*p[1][0] + 1.5*p[1][1] - 1.5*p[1][2] + .5*p[1][3];  
  88.         a10 = -.5*p[0][1] + .5*p[2][1];  
  89.         a11 = .25*p[0][0] - .25*p[0][2] - .25*p[2][0] + .25*p[2][2];  
  90.         a12 = -.5*p[0][0] + 1.25*p[0][1] - p[0][2] + .25*p[0][3] + .5*p[2][0] - 1.25*p[2][1] + p[2][2] - .25*p[2][3];  
  91.         a13 = .25*p[0][0] - .75*p[0][1] + .75*p[0][2] - .25*p[0][3] - .25*p[2][0] + .75*p[2][1] - .75*p[2][2] + .25*p[2][3];  
  92.         a20 = p[0][1] - 2.5*p[1][1] + 2*p[2][1] - .5*p[3][1];  
  93.         a21 = -.5*p[0][0] + .5*p[0][2] + 1.25*p[1][0] - 1.25*p[1][2] - p[2][0] + p[2][2] + .25*p[3][0] - .25*p[3][2];  
  94.         a22 = p[0][0] - 2.5*p[0][1] + 2*p[0][2] - .5*p[0][3] - 2.5*p[1][0] + 6.25*p[1][1] - 5*p[1][2] + 1.25*p[1][3] + 2*p[2][0] - 5*p[2][1] + 4*p[2][2] - p[2][3] - .5*p[3][0] + 1.25*p[3][1] - p[3][2] + .25*p[3][3];  
  95.         a23 = -.5*p[0][0] + 1.5*p[0][1] - 1.5*p[0][2] + .5*p[0][3] + 1.25*p[1][0] - 3.75*p[1][1] + 3.75*p[1][2] - 1.25*p[1][3] - p[2][0] + 3*p[2][1] - 3*p[2][2] + p[2][3] + .25*p[3][0] - .75*p[3][1] + .75*p[3][2] - .25*p[3][3];  
  96.         a30 = -.5*p[0][1] + 1.5*p[1][1] - 1.5*p[2][1] + .5*p[3][1];  
  97.         a31 = .25*p[0][0] - .25*p[0][2] - .75*p[1][0] + .75*p[1][2] + .75*p[2][0] - .75*p[2][2] - .25*p[3][0] + .25*p[3][2];  
  98.         a32 = -.5*p[0][0] + 1.25*p[0][1] - p[0][2] + .25*p[0][3] + 1.5*p[1][0] - 3.75*p[1][1] + 3*p[1][2] - .75*p[1][3] - 1.5*p[2][0] + 3.75*p[2][1] - 3*p[2][2] + .75*p[2][3] + .5*p[3][0] - 1.25*p[3][1] + p[3][2] - .25*p[3][3];  
  99.         a33 = .25*p[0][0] - .75*p[0][1] + .75*p[0][2] - .25*p[0][3] - .75*p[1][0] + 2.25*p[1][1] - 2.25*p[1][2] + .75*p[1][3] + .75*p[2][0] - 2.25*p[2][1] + 2.25*p[2][2] - .75*p[2][3] - .25*p[3][0] + .75*p[3][1] - .75*p[3][2] + .25*p[3][3];  
  100.     }  
  101.       
  102.     public double getValue (double x, double y) {  
  103.         double x2 = x * x;  
  104.         double x3 = x2 * x;  
  105.         double y2 = y * y;  
  106.         double y3 = y2 * y;  
  107.   
  108.         return (a00 + a01 * y + a02 * y2 + a03 * y3) +  
  109.                (a10 + a11 * y + a12 * y2 + a13 * y3) * x +  
  110.                (a20 + a21 * y + a22 * y2 + a23 * y3) * x2 +  
  111.                (a30 + a31 * y + a32 * y2 + a33 * y3) * x3;  
  112.     }  
  113.   
  114.     /* <p> The purpose of this method is to convert the data in the 3D array of ints back into </p> 
  115.      * <p> the 1d array of type int. </p> 
  116.      *  
  117.      */  
  118.     public int[] convertToOneDim(int[][][] data, int imgCols, int imgRows) {  
  119.         // Create the 1D array of type int to be populated with pixel data  
  120.         int[] oneDPix = new int[imgCols * imgRows * 4];  
  121.   
  122.         // Move the data into the 1D array. Note the  
  123.         // use of the bitwise OR operator and the  
  124.         // bitwise left-shift operators to put the  
  125.         // four 8-bit bytes into each int.  
  126.         for (int row = 0, cnt = 0; row < imgRows; row++) {  
  127.             for (int col = 0; col < imgCols; col++) {  
  128.                 oneDPix[cnt] = ((data[row][col][0] << 24) & 0xFF000000)  
  129.                         | ((data[row][col][1] << 16) & 0x00FF0000)  
  130.                         | ((data[row][col][2] << 8) & 0x0000FF00)  
  131.                         | ((data[row][col][3]) & 0x000000FF);  
  132.                 cnt++;  
  133.             }// end for loop on col  
  134.   
  135.         }// end for loop on row  
  136.   
  137.         return oneDPix;  
  138.     }// end convertToOneDim  
  139.       
  140.     private double [][][] processOneToThreeDeminsion(int[] oneDPix2, int imgRows, int imgCols) {  
  141.         double[][][] tempData = new double[imgRows][imgCols][4];  
  142.         for(int row=0; row<imgRows; row++) {  
  143.               
  144.             // per row processing  
  145.             int[] aRow = new int[imgCols];  
  146.             for (int col = 0; col < imgCols; col++) {  
  147.                 int element = row * imgCols + col;  
  148.                 aRow[col] = oneDPix2[element];  
  149.             }  
  150.               
  151.             // convert to three dimension data  
  152.             for(int col=0; col<imgCols; col++) {  
  153.                 tempData[row][col][0] = (aRow[col] >> 24) & 0xFF; // alpha  
  154.                 tempData[row][col][1] = (aRow[col] >> 16) & 0xFF; // red  
  155.                 tempData[row][col][2] = (aRow[col] >> 8) & 0xFF;  // green  
  156.                 tempData[row][col][3] = (aRow[col]) & 0xFF;       // blue  
  157.             }  
  158.         }  
  159.         return tempData;  
  160.     }  
  161. }  
文章标签：
Java
算法
毛毛虫的爹
目录
相关文章
Lucky小黄人^_^
利用矩阵进行平移，旋转，缩放等图像变换、创建第二个一模一样的图像并使之进行缩放等操作
利用矩阵进行平移，旋转，缩放等图像变换、创建第二个一模一样的图像并使之进行缩放等操作
Lucky小黄人^_^
77 0
陈言必行
|
图形学
Unity 之 获取物体的旋转角正确数值
不管父物体如何设置，都能获取到物体本身旋转角度的正确数值
陈言必行
929 0
Vuko-wxh
FPGA-像素操作（二值图片，异或操作，暗通道rgb）
FPGA-像素操作（二值图片，异或操作，暗通道rgb）
Vuko-wxh
185 0
FPGA-像素操作（二值图片，异或操作，暗通道rgb）
爱打瞌睡的CV君
第五周作业：利用matlab将图片依次进行，平移、镜像、旋转、0.5 倍缩小，然后分别将变换后的图像进行二维傅里叶变换。
简介：第五周作业：利用matlab将图片依次进行，平移、镜像、旋转、0.5 倍缩小，然后分别将变换后的图像进行二维傅里叶变换。
爱打瞌睡的CV君
297 0
第五周作业：利用matlab将图片依次进行，平移、镜像、旋转、0.5 倍缩小，然后分别将变换后的图像进行二维傅里叶变换。
fengzhizi715
|
算法 Java 计算机视觉
常用的像素操作算法：图像加法、像素混合、提取图像中的ROI
常用的像素操作算法：图像加法、像素混合、提取图像中的ROI
fengzhizi715
309 0
常用的像素操作算法：图像加法、像素混合、提取图像中的ROI
梅花落
|
算法 计算机视觉 异构计算
双三次插值算法的OpenGL实现
双三次插值算法的OpenGL实现 说明 最近写一个图像缩放的接口，考虑到自己有现成的OpenGL图像处理引擎，还是直接写shader用GPU实现方便。为了效果好一些，采用了双三次插值算法。 算法相关公式可参考这篇文章： http://blog.csdn.net/lichengyu/article/details/8526629 代码 详细实现代码见： htt
梅花落
3611 0
y2hr4cjzssnlm
Halcon标定系列（5）：4点标定之眼在手外项目实践，已知仿射变换矩阵，计算得到旋转角度和缩放因子等参数
Halcon标定系列（5）：4点标定之眼在手外项目实践，已知仿射变换矩阵，计算得到旋转角度和缩放因子等参数
y2hr4cjzssnlm
807 0
Halcon标定系列（5）：4点标定之眼在手外项目实践，已知仿射变换矩阵，计算得到旋转角度和缩放因子等参数
spaceack
|
Python
基于相同颜色连通像素个数的统计进行图像字符识别
无论是图像，音频的识别，不外乎是对各种特征(特征向量)进行统计归纳。 通过观察，发现这是一张简单的，非常有规律可循的图。 越有规律越容易进行分类。这里的思路就是自左至右依次对相同颜色的像素连通区进行像素个数统计，从而制成像素与字符对应的字典进行识别。
spaceack
142 0
基于相同颜色连通像素个数的统计进行图像字符识别
开开心心过
积分计算两条曲线围绕y坐标轴旋转形成的立体体积
积分计算两条曲线围绕y坐标轴旋转形成的立体体积 和附录文章1类似，计算两条曲线y=x^2和y=2x围绕y坐标轴形成的立方体体积，首先要计算积分的上限和下限，根据两者相交的点求出[0,4]。
开开心心过
1532 0
开开心心过
积分计算曲线围绕X轴旋转形成的立体体积
积分计算曲线围绕X轴旋转形成的立体体积 若曲线y=x^2+1和直线y=-x+3围成的区域，再绕X坐标轴旋转一周，形成一个立体，计算该立体的体积。
开开心心过
1734 0