双线性插值算法原理及其实现

双线性插值原理部分：转自http://handspeaker.iteye.com/blog/1545126

最近在编程时用到了双线性插值算法，对图像进行缩放。网上有很多这方面的资料，介绍的也算明白。但是，这些文章只介绍了算法，并没有具体说怎么实现以及怎么实现最好，举个例子，你可以按照网上文章的算法自己写一个双线性插值程序，用它对一张图片进行处理，然后再用matlab或者openCV的resize函数对同一张图片进行处理，得到的结果是不一样的，如果源图片较小，效果差距就更大。以下是对于双线性插值的讲解以及上述现象的解释：

1.双线性插值

假设源图像大小为mxn，目标图像为axb。那么两幅图像的边长比分别为：m/a和n/b。注意，通常这个比例不是整数，编程存储的时候要用浮点型。目标图像的第（i,j）个像素点（i行j列）可以通过边长比对应回源图像。其对应坐标为（i*m/a,j*n/b）。

显然，这个对应坐标一般来说不是整数，而非整数的坐标是无法在图像这种离散数据上使用的。双线性插值通过寻找距离这个对应坐标最近的四个像素点，来计算该点的值（灰度值或者RGB值）。如果你的对应坐标是（2.5,4.5），那么最近的四个像素是（2，4）、（2，5）、（3，4），（3，5）。

若图像为灰度图像，那么（i，j）点的灰度值可以通过一下公式计算：

f(i,j)=w1*p1+w2*p2+w3*p3+w4*p4;

其中，pi(i=1,2,3,4)为最近的四个像素点，wi(i=1,2,3,4)为各点相应权值。关于权值的计算，在维基百科和百度百科上写的很明白。

2.存在的问题

这部分的前提是，你已经明白什么是双线性插值并且在给定源图像和目标图像尺寸的情况下，可以用笔计算出目标图像某个像素点的值。当然，最好的情况是你已经用某种语言实现了网上一大堆博客上原创或转载的双线性插值算法，然后发现计算出来的结果和matlab、openCV对应的resize（）函数得到的结果完全不一样。

那这个究竟是怎么回事呢？

其实答案很简单，就是坐标系的选择问题，或者说源图像和目标图像之间的对应问题。

按照网上一些博客上写的，源图像和目标图像的原点（0，0）均选择左上角，然后根据插值公式计算目标图像每点像素，假设你需要将一幅5x5的图像缩小成3x3，那么源图像和目标图像各个像素之间的对应关系如下：

只画了一行，用做示意，从图中可以很明显的看到，如果选择右上角为原点（0，0），那么最右边和最下边的像素实际上并没有参与计算，而且目标图像的每个像素点计算出的灰度值也相对于源图像偏左偏上。

那么，让坐标加1或者选择右下角为原点怎么样呢？很不幸，还是一样的效果，不过这次得到的图像将偏右偏下。

最好的方法就是，两个图像的几何中心重合，并且目标图像的每个像素之间都是等间隔的，并且都和两边有一定的边距，这也是matlab和openCV的做法。如下图：

如果你不懂我上面说的什么，没关系，只要在计算对应坐标的时候改为以下公式即可，

 

int x=(i+0.5)*m/a-0.5

int y=(j+0.5)*n/b-0.5

 

instead of 

 

 

int x=i*m/a

int y=j*n/b

利用上述公式，将得到正确的双线性插值结果

总结：

总结一下，我得到的教训有这么几条。

1.网上的一些资料有的时候并不靠谱，自己还是要多做实验。

2.不要小瞧一些简单的、基本的算法，让你写你未必会写，而且其中可能还藏着一些玄妙。

3.要多动手编程，多体会算法，多看大牛写的源码（虽然有的时候很吃力，但是要坚持看）。

实现部分

1. cv::Mat matSrc, matDst1, matDst2;  
2.   
3. matSrc = cv::imread("lena.jpg", 2 | 4);  
4. matDst1 = cv::Mat(cv::Size(800, 1000), matSrc.type(), cv::Scalar::all(0));  
5. matDst2 = cv::Mat(matDst1.size(), matSrc.type(), cv::Scalar::all(0));  
6.   
7. double scale_x = (double)matSrc.cols / matDst1.cols;  
8. double scale_y = (double)matSrc.rows / matDst1.rows;  
9. 1. uchar* dataDst = matDst1.data;  
   2. int stepDst = matDst1.step;  
   3. uchar* dataSrc = matSrc.data;  
   4. int stepSrc = matSrc.step;  
   5. int iWidthSrc = matSrc.cols;  
   6. int iHiehgtSrc = matSrc.rows;  
   7.   
   8. for (int j = 0; j < matDst1.rows; ++j)  
   9. {  
   10.     float fy = (float)((j + 0.5) * scale_y - 0.5);  
   11.     int sy = cvFloor(fy);  
   12.     fy -= sy;  
   13.     sy = std::min(sy, iHiehgtSrc - 2);  
   14.     sy = std::max(0, sy);  
   15.   
   16.     short cbufy[2];  
   17.     cbufy[0] = cv::saturate_cast<short>((1.f - fy) * 2048);  
   18.     cbufy[1] = 2048 - cbufy[0];  
   19.   
   20.     for (int i = 0; i < matDst1.cols; ++i)  
   21.     {  
   22.         float fx = (float)((i + 0.5) * scale_x - 0.5);  
   23.         int sx = cvFloor(fx);  
   24.         fx -= sx;  
   25.   
   26.         if (sx < 0) {  
   27.             fx = 0, sx = 0;  
   28.         }  
   29.         if (sx >= iWidthSrc - 1) {  
   30.             fx = 0, sx = iWidthSrc - 2;  
   31.         }  
   32.   
   33.         short cbufx[2];  
   34.         cbufx[0] = cv::saturate_cast<short>((1.f - fx) * 2048);  
   35.         cbufx[1] = 2048 - cbufx[0];  
   36.   
   37.         for (int k = 0; k < matSrc.channels(); ++k)  
   38.         {  
   39.             *(dataDst+ j*stepDst + 3*i + k) = (*(dataSrc + sy*stepSrc + 3*sx + k) * cbufx[0] * cbufy[0] +   
   40.                 *(dataSrc + (sy+1)*stepSrc + 3*sx + k) * cbufx[0] * cbufy[1] +   
   41.                 *(dataSrc + sy*stepSrc + 3*(sx+1) + k) * cbufx[1] * cbufy[0] +   
   42.                 *(dataSrc + (sy+1)*stepSrc + 3*(sx+1) + k) * cbufx[1] * cbufy[1]) >> 22;  
   43.         }  
   44.     }  
   45. }  
   46. cv::imwrite("linear_1.jpg", matDst1);  
   47.   
   48. cv::resize(matSrc, matDst2, matDst1.size(), 0, 0, 1);  
   49. cv::imwrite("linear_2.jpg", matDst2);