图像缩放算法

第一篇文章.

插值算法对于缩放比例较小的情况是完全可以接受的，令人信服的。一般的，缩小0.5倍以上或放大3.0倍以下，对任何图像都是可以接受的。

最邻近插值（近邻取样法）：
　　最临近插值的的思想很简单。对于通过反向变换得到的的一个浮点坐标，对其进行简单的取整，得到一个整数型坐标，这个整数型坐标对应的像素值就是目的像素的像素值，也就是说，取浮点坐标最邻近的左上角点（对于DIB是右上角，因为它的扫描行是逆序存储的）对应的像素值。可见，最邻近插值简单且直观，但得到的图像质量不高

双线性内插值：
　　对于一个目的像素，设置坐标通过反向变换得到的浮点坐标为(i+u,j+v)，其中i、j均为非负整数，u、v为[0,1)区间的浮点数，则这个像素得值 f(i+u,j+v) 可由原图像中坐标为 (i,j)、(i+1,j)、(i,j+1)、(i+1,j+1)所对应的周围四个像素的值决定，即：

　　　　f(i+u,j+v) = (1-u)(1-v)f(i,j) + (1-u)vf(i,j+1) + u(1-v)f(i+1,j) + uvf(i+1,j+1)

其中f(i,j)表示源图像(i,j)处的的像素值，以此类推
　　这就是双线性内插值法。双线性内插值法计算量大，但缩放后图像质量高，不会出现像素值不连续的的情况。由于双线性插值具有低通滤波器的性质，使高频分量受损，所以可能会使图像轮廓在一定程度上变得模糊

　　三次卷积法能够克服以上两种算法的不足，计算精度高，但计算亮大，他考虑一个浮点坐标(i+u,j+v)周围的16个邻点，目的像素值f(i+u,j+v)可由如下插值公式得到：

　　　　f(i+u,j+v) = [A] * [B] * [C]

[A]=[ S(u + 1)　S(u + 0)　S(u - 1)　S(u - 2) ]

　　┏ f(i-1, j-1)　f(i-1, j+0)　f(i-1, j+1)　f(i-1, j+2) ┓
[B]=┃ f(i+0, j-1)　f(i+0, j+0)　f(i+0, j+1)　f(i+0, j+2) ┃
　　┃ f(i+1, j-1)　f(i+1, j+0)　f(i+1, j+1)　f(i+1, j+2) ┃
　　┗ f(i+2, j-1)　f(i+2, j+0)　f(i+2, j+1)　f(i+2, j+2) ┛

　　┏ S(v + 1) ┓
[C]=┃ S(v + 0) ┃
　　┃ S(v - 1) ┃
　　┗ S(v - 2) ┛

　　 ┏ 1-2*Abs(x)^2+Abs(x)^3　　　　　 , 0<=Abs(x)<1
S(x)=｛ 4-8*Abs(x)+5*Abs(x)^2-Abs(x)^3　, 1<=Abs(x)<2
　　 ┗ 0　　　　　　　　　　　　　　　 , Abs(x)>=2
S(x)是对 Sin(x*Pi)/x 的逼近（Pi是圆周率——π）

最邻近插值（近邻取样法）、双线性内插值、三次卷积法 等插值算法对于旋转变换、错切变换、一般线性变换 和 非线性变换 都适用。

第二篇文章.

“插值”最初是电脑的术语，后来引用到数码图像上来。图像放大时，像素也相应地增加，但这些增加的像素从何而来？这时插值就派上用场了：插值就是在不生成像素的情况下增加图像像素大小的一种方法，在周围像素色彩的基础上用数学公式计算丢失像素的色彩（也有的有些相机使用插值，人为地增加图像的分辨率）。所以在放大图像时，图像看上去会比较平滑、干净。但必须注意的是插值并不能增加图像信息。
1.         最近像素插值算法（Nearest Neighbour interpolation）
　　最近像素插值算法是最简单的一种插值算法，当图片放大时，缺少的像素通过直接使用与之最接近的原有的像素的颜色生成，也就是说照搬旁边的像素，这样做的结果是产生了明显可见的锯齿。
2.         双线性插值（Bilinear interpolation）
　　这种算法输出的图像的每个像素都是原图中四个像素（2×2）运算的结果，这种算法极大地消除了锯齿现象
3.         双三次插值算法（Bicubic interpolation）
　　这种算法是上一种算法的改进算法，它输出图像的每个像素都是原图16个像素（16×16）运算的结果。这种算法是一种很常见的算法，普遍用在图像编辑软件、打印机驱动和数码相机上。
4.         分形算法（Fractal interpolation）
　　这是Altamira Group提出的一种算法，这种算法得到的图像跟其它算法相比更清晰、锐利。
　　现在有许多数码相机生产商将插值算法用在了数码相机上，并将通过算法得到的分辨率值大肆宣传，固然他们的算法比双三次插值算法等算法先进很多，但是事实是：图像的细节是不能凭空造出来的。对数码相机不是很熟悉的消费者在购买时一定要注意这个问题。
 
在Windows中做过图像方面程序的人应该都知道Windows的GDI有一个API函数：StretchBlt，对应在VCL中是TCanvas类的StretchDraw方法。它可以很简单地实现图像的缩放操作。但问题是它是用了速度最快，最简单但效果也是最差的“最近邻域法”，虽然在大多数情况下，它也够用了，但对于要求较高的情况就不行了。
 
经过研究发现三次样条法的计算量实在太大，不太实用，所以决定就只做线性插值法的版本了。
 
从数字图像处理的基本理论，我们可以知道：图像的变形变换就是源图像到目标图像的坐标变换。简单的想法就是把源图像的每个点坐标通过变形运算转为目标图像的相应点的新坐标，但是这样会导致一个问题就是目标点的坐标通常不会是整数，而且像放大操作会导致目标图像中没有被源图像的点映射到，这是所谓“向前映射”方法的缺点。所以一般都是采用“逆向映射”法。
 
但是逆向映射法同样会出现映射到源图像坐标时不是整数的问题。这里就需要“重采样滤波器”，确定这个非整数坐标处的点应该是什么颜色的问题。前面说到的三种方法：最近邻域法，线性插值法和三次样条法都是所谓的“重采样滤波器”。
 
所谓“最近邻域法”就是把这个非整数坐标作一个四舍五入，取最近的整数点坐标处的点的颜色。
而“线性插值法”就是根据周围最接近的几个点（对于平面图像来说，共有四点）的颜色作线性插值计算（对于平面图像来说就是二维线性插值）来估计这点的颜色，在大多数情况下，它的准确度要高于最近邻域法，当然效果也要好得多，最明显的就是在放大时，图像边缘的锯齿比最近邻域法小非常多。当然它同时还带来一个问题：就是图像会显得比较柔和。
至于三次样条法我就不说了，复杂了一点，可自行参考数字图像处理方面的专业书籍，如本文的参考文献。
 
再来讨论一下坐标变换的算法。简单的空间变换可以用一个变换矩阵来表示：
 
[x’,y’,w’]=[u,v,w]*T
 
其中：x’,y’为目标图像坐标，u,v为源图像坐标，w,w’称为齐次坐标，通常设为1，T为一个3X3的变换矩阵。
 
这种表示方法虽然很数学化，但是用这种形式可以很方便地表示多种不同的变换，如平移，旋转，缩放等。对于缩放来说，相当于：
 
          [Su 0 0 ]
 
[x, y, 1] = [u, v, 1] * | 0 Sv 0 |
 
          [0   0 1 ]
 
其中Su,Sv分别是X轴方向和Y轴方向上的缩放率，大于1时放大，大于0小于1时缩小，小于0时反转。
 
矩阵是不是看上去比较晕？其实把上式按矩阵乘法展开就是：
 
{ x = u * Su
 
{ y = v * Sv
 
就这么简单。^_^
 
有了上面三个方面的准备，就可以开始编写代码实现了。思路很简单：首先用两重循环遍历目标图像的每个点坐标，通过上面的变换式（注意：因为是用逆向映射，相应的变换式应该是：u = x / Su 和v = y / Sv）取得源坐标。因为源坐标不是整数坐标，需要进行二维线性插值运算：
 
P = n*b*PA + n * ( 1 – b )*PB + ( 1 – n ) * b * PC + ( 1 – n ) * ( 1 – b ) * PD
 
其中：n为v（映射后相应点在源图像中的Y轴坐标，一般不是整数）下面最接近的行的Y轴坐标与v的差；同样b也类似，不过它是X轴坐标。PA-PD分别是(u,v)点周围最接近的四个（左上，右上，左下，右下）源图像点的颜色（用TCanvas的Pixels属性）。P为(u,v)点的插值颜色，即(x,y)点的近似颜色。
 
这段代码我就不写的，因为它的效率实在太低：要对目标图像的每一个点的RGB进行上面那一串复杂的浮点运算。所以一定要进行优化。对于VCL应用来说，有个比较简单的优化方法就是用TBitmap的ScanLine属性，按行进行处理，可以避免Pixels的像素级操作，对性能可以有很大的改善。这已经是算是用VCL进行图像处理的基本优化常识了。不过这个方法并不总是管用的，比如作图像旋转的时候，这时需要更多的技巧。
 
无论如何，浮点运算的开销都是比整数大很多的，这个也是一定要优化掉的。从上面可以看出，浮点数是在变换时引入的，而变换参数Su,Sv通常就是浮点数，所以就从它下手优化。一般来说，Su,Sv可以表示成分数的形式：
 
Su = ( double )Dw / Sw; Sv = ( double )Dh / Sh
 
其中Dw, Dh为目标图像的宽度和高度，Sw, Sh为源图像的宽度和高度（因为都是整数，为求得浮点结果，需要进行类型转换）。
 
将新的Su, Sv代入前面的变换公式和插值公式，可以导出新的插值公式：
 
因为：
 
b = 1 – x * Sw % Dw / ( double )Dw; n = 1 – y * Sh % Dh / ( double )Dh
 
设：
 
B = Dw – x * Sw % Dw; N = Dh – y * Sh % Dh
 
则：
 
b = B / ( double )Dw; n = N / ( double )Dh
 
用整数的B，N代替浮点的b, n，转换插值公式：
 
P = ( B * N * ( PA – PB – PC + PD ) + Dw * N * PB + DH * B * PC + ( Dw * Dh – Dh * B – Dw * N ) * PD ) / ( double )( Dw * Dh )
 
这里最终结果P是浮点数，对其四舍五入即可得到结果。为完全消除浮点数，可以用这样的方法进行四舍五入：
 
P = ( B * N … * PD + Dw * Dh / 2 ) / ( Dw * Dh )
 
这样，P就直接是四舍五入后的整数值，全部的计算都是整数运算了。
 
简单优化后的代码如下：
 
int __fastcall TResizeDlg::Stretch_Linear(Graphics::TBitmap * aDest, Graphics::TBitmap * aSrc)
 
{
 
    int sw = aSrc->Width - 1, sh = aSrc->Height - 1, dw = aDest->Width - 1, dh = aDest->Height - 1;
 
    int B, N, x, y;
 
    int nPixelSize = GetPixelSize( aDest->PixelFormat );
 
    BYTE * pLinePrev, *pLineNext;
 
    BYTE * pDest;
 
    BYTE * pA, *pB, *pC, *pD;
 
    for ( int i = 0; i <= dh; ++i )
 
    {
 
        pDest = ( BYTE * )aDest->ScanLine[i];
 
        y = i * sh / dh;
 
        N = dh - i * sh % dh;
 
        pLinePrev = ( BYTE * )aSrc->ScanLine[y++];
 
        pLineNext = ( N == dh ) ? pLinePrev : ( BYTE * )aSrc->ScanLine[y];
 
        for ( int j = 0; j <= dw; ++j )
 
        {
 
            x = j * sw / dw * nPixelSize;
 
            B = dw - j * sw % dw;
 
            pA = pLinePrev + x;
 
            pB = pA + nPixelSize;
 
            pC = pLineNext + x;
 
            pD = pC + nPixelSize;
 
            if ( B == dw )
 
            {
 
                pB = pA;
 
                pD = pC;
 
            }
 
            for ( int k = 0; k < nPixelSize; ++k )
 
                *pDest++ = ( BYTE )( int )(
 
                    ( B * N * ( *pA++ - *pB - *pC + *pD ) + dw * N * *pB++
 
                    + dh * B * *pC++ + ( dw * dh - dh * B - dw * N ) * *pD++
 
                    + dw * dh / 2 ) / ( dw * dh )
 
                );
 
        }
 
    }
 
    return 0;
 
}
 
应该说还是比较简洁的。因为宽度高度都是从0开始算，所以要减一，GetPixelSize是根据PixelFormat属性来判断每个像素有多少字节，此代码只支持24或32位色的情况（对于15或16位色需要按位拆开—因为不拆开的话会在计算中出现不期望的进位或借位，导致图像颜色混乱—处理较麻烦；对于8位及8位以下索引色需要查调色板，并且需要重索引，也很麻烦，所以都不支持；但8位灰度图像可以支持）。另外代码中加入一些在图像边缘时防止访问越界的代码。
 
通过比较，在PIII-733的机器上，目标图像小于1024x768的情况下，基本感觉不出速度比StretchDraw有明显的慢（用浮点时感觉比较明显）。效果也相当令人满意，不论是缩小还是放大，图像质量比StretchDraw方法有明显提高。
 
不过由于采用了整数运算，有一个问题必须加以重视，那就是溢出的问题：由于式中的分母是dw * dh，而结果应该是一个Byte即8位二进制数，有符号整数最大可表示31位二进制数，所以dw * dh的值不能超过23位二进制数，即按2:1的宽高比计算目标图像分辨率不能超过4096*2048。当然这个也是可以通过用无符号数（可以增加一位）及降低计算精度等方法来实现扩展的，有兴趣的朋友可以自己试试。
 
当然这段代码还远没有优化到极致，而且还有很多问题没有深入研究，比如抗混叠（anti-aliasing）等，有兴趣的朋友可以自行参考相关书籍研究

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/huahua70528158/archive/2007/10/17/1829302.aspx