图像的三次B样条插值原理与C++实现


01 前言

前文我们讲过图像中最常用的三种插值算法:最邻近插值、双线性插值、双三次插值

常见图像插值算法的原理与C++实现icon-default.png?t=M1L8https://mp.weixin.qq.com/s/G9xXJKwuIHm4KyDndVKRxw

双三次插值算法的C++实现与SSE指令优化icon-default.png?t=M1L8https://mp.weixin.qq.com/s/B7ocbmh2Uep9205DA8yaJw

插值的本质,就是使用周围点的值来计算插值点的值,如下图所示,红点的值已知,黑点的值未知,那么通过一定算法,使用黑点周围红点的值来计算黑点的值,就是插值。

图像的三次B样条插值原理与C++实现_第1张图片

在图像中也是类似的,整型坐标点的像素值已知,浮点型坐标点的像素值未知,所以如果想求浮点型坐标点的像素值,则需要使用其周围整型坐标点的像素值来计算,如下图所示:

图像的三次B样条插值原理与C++实现_第2张图片


02 三次B样条插值原理

图像处理中几种常见的插值算法基本都是取浮点型坐标点周围的n*n个整型坐标点的像素值进行加权和,从而得到该浮点型坐标点的像素值,不同插值算法的主要区别在于权重计算方法,如下式(其中W为权重):

4ede6d97dc9e242ef9e91982a15f5453.png

三次B样条插值与双三次插值的原理几乎一样,区别仅在于插值的基函数不一样,所以我们先来复习一下双三次插值原理。

如下图,假设想求图像中浮点型坐标点(x', y')的像素值。

图像的三次B样条插值原理与C++实现_第3张图片

双三次插值算法使用点(x', y')周围4*4个整型点的像素值来计算点(x', y')的像素值。如下式,其中I表示像素值,W表示权重。

8201df5b0035d625edd5b526d877e444.png

权重W(i,j)的计算如下式,其中a取值范围-1~0之间,一般取固定值-0.5,p(i,j).x和p(i,j).y分别表示点p(i,j)的x坐标、y坐标。

图像的三次B样条插值原理与C++实现_第4张图片

上式中函数w(d)通常被称为双三次插值的基函数,三次B样条插值除了基函数与双三次插值不一样,其它都相同,其基函数如下:

图像的三次B样条插值原理与C++实现_第5张图片


03 几种常见插值算法的总结与比较

  • 最邻近插值算法

最邻近插值取离浮点型坐标点的最近点像素值作为其像素值,也可以看成使用浮点型坐标点周围2*2个整型点的像素值来计算其像素值,不过只有最靠近的那个点权重为1,其余3个点权重系数都为0。

图像的三次B样条插值原理与C++实现_第6张图片

  • 双线性插值算法

双线性插值与最邻近插值类似,同样使用浮点型坐标点周围2*2个整型点的像素值来计算其像素值,不过其周围每个整型点的权重都不为0。

图像的三次B样条插值原理与C++实现_第7张图片

  • 双三次插值算法

双三次插值使用浮点型坐标点周围4*4个整型点的像素值来计算其像素值。

图像的三次B样条插值原理与C++实现_第8张图片

  • 三次B样条插值算法

三次B样条插值除了基函数与双三次插值不一样,其它都相同。

图像的三次B样条插值原理与C++实现_第9张图片

下面我们取d从-2.5到2.5,数据点间隔0.01,分别画出以上几种插值算法的基函数曲线。从曲线可以知道,d越小,也即周围整型点越靠近插值点,那么该整型点的权重越大。从曲线平滑度来看:三次B样条插值>双三次插值>双线性插值>最邻近插值

图像的三次B样条插值原理与C++实现_第10张图片


04 几种常见插值算法的代码实现

  • 最近邻插值算法的代码实现

最邻近插值取离浮点型坐标点的最近点像素值作为其像素值,也即相当于对浮点型x、y坐标分别四舍五入,从而得到最近点的整型坐标。

//src--uchar型图像数据
//x_float--浮点型的x坐标
//y_float--浮点型的y坐标
uchar nearst_inner(Mat src, float x_float, float y_float)
{
    int x = (int)(x_float + 0.5);   //四舍五入
    int y = (int)(y_float + 0.5);   //四舍五入


    return src.ptr(y)[x];
}
  • 双线性插值算法的代码实现

//基函数
float line_w_f(float x)
{
    return (abs(x) <= 1) ? (1 - abs(x)) : 0; 
}


//src--uchar型图像数据
//x_float--浮点型的x坐标
//y_float--浮点型的y坐标
uchar line_inner(Mat src, float x_float, float y_float)
{
    int x = floor(x_float);
    int y = floor(y_float);
   
    float a0_0 = line_w_f(x - x_float) * line_w_f(y - y_float);
    float a0_1 = line_w_f(x + 1 - x_float) * line_w_f(y - y_float);
    float a1_0 = line_w_f(x - x_float) * line_w_f(y + 1 - y_float);
    float a1_1 = line_w_f(x + 1 - x_float) * line_w_f(y + 1 - y_float);
    
    float sum = src.ptr(y)[x] * a0_0 + src.ptr(y)[x + 1] * a0_1 + src.ptr(y + 1)[x] * a1_0 + src.ptr(y + 1)[x + 1] * a1_1;


    return ((uchar)sum);
}
  • 双三次插值算法的代码实现

//基函数
float cubic_w_f(float x, float a)
{
    if (x <= 1)
    {
        return 1 - (a + 3) * x * x + (a + 2) * x * x * x;
    }
    else if (x < 2)
    {
        return -4 * a + 8 * a * x - 5 * a * x * x + a * x * x * x;
    }
    return 0.0;
}


//计算权重系数
void cal_cubic_coeff(float x, float y, float* coeff)
{
    float u = x - floor(x) + 1;
    float v = y - floor(y) + 1;
    float a = -0.15;


    float A[4];
    A[0] = cubic_w_f(abs(u), a);
    A[1] = cubic_w_f(abs(u - 1), a);
    A[2] = cubic_w_f(abs(u - 2), a);
    A[3] = cubic_w_f(abs(u - 3), a);


    for (int s = 0; s < 4; s++)
    {
        float C = cubic_w_f(abs(v - s), a);
        coeff[s * 4] = A[0] * C;
        coeff[s * 4 + 1] = A[1] * C;
        coeff[s * 4 + 2] = A[2] * C;
        coeff[s * 4 + 3] = A[3] * C;
    }
}


//双三次插值
uchar cubic_inner(Mat src, float x_float, float y_float, float a)
{
    float coeff[16];
    cal_cubic_coeff(x_float, y_float, coeff);  //计算权重系数




    float sum = 0.0;
    int x0 = floor(x_float) - 1;
    int y0 = floor(y_float) - 1;




    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            sum += coeff[i * 4 + j] * src.ptr(y0 + i)[x0 + j];
        }
    }
    return ((uchar)sum);
}
  • 三次B样条插值算法的代码实现

//基函数
float bpline_w_f(float x)
{
    if (x <= 1)
    {
        return 2.0/3.0 - (1.0 - x/2.0)*x*x;
    }
    else if (x > 1 && x <= 2)
    {
        return (2.0 - x) * (2.0 - x) * (2.0 - x) / 6.0;;
    }


    return 0.0;
}


//计算权重系数
void cal_bpline_coeff(float x, float y, float* coeff)
{
    float u = x - floor(x) + 1;
    float v = y - floor(y) + 1;


    float A[4];
    A[0] = bpline_w_f(abs(u));
    A[1] = bpline_w_f(abs(u - 1));
    A[2] = bpline_w_f(abs(u - 2));
    A[3] = bpline_w_f(abs(u - 3));


    for (int s = 0; s < 4; s++)
    {
        float C = bpline_w_f(abs(v - s));
        coeff[s * 4] = A[0] * C;
        coeff[s * 4 + 1] = A[1] * C;
        coeff[s * 4 + 2] = A[2] * C;
        coeff[s * 4 + 3] = A[3] * C;  
    }
  
}


//三次B样条插值
uchar bpline_inner(Mat src, float x_float, float y_float)
{
    float coeff[16];
    cal_bpline_coeff(x_float, y_float, coeff);  //计算权重系数




    float sum = 0.0;
    int x0 = floor(x_float) - 1;
    int y0 = floor(y_float) - 1;


    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {         
            sum += coeff[i * 4 + j] * src.ptr(y0 + i)[x0 + j];
        }
    }
    return ((uchar)sum);
}

05 几种常见插值算法应用于图像缩放的结果对比

将以上几种插值算法分别应用于Lena图像的缩放,测试代码如下:

//src -- 输入图像
//dst -- 输出图像
//row_m -- 行的缩放倍数
//col_m -- 列的缩放倍数
//inner_type -- 插值类型 0:最邻近,1:双线性,2:双三次,3:三次B样条
void resize_img(Mat src, Mat& dst, float row_m, float col_m, int inner_type)
{
    const int row = (int)(src.rows * row_m);
    const int col = (int)(src.cols * col_m);
    const float x_a = 1.0 / col_m;
    const float y_a = 1.0 / row_m;


    Mat dst_tmp = Mat::zeros(row, col, CV_8UC1);


    if (inner_type == 0)
    {
        for (int i = 0; i < row; i++)
        {
            uchar* p = dst_tmp.ptr(i);
            float y = i * y_a;


            for (int j = 0; j < col; j++)
            {
                float x = j * x_a;


                p[j] = nearst_inner(src, x, y);


            }
        }
    }
    else if (inner_type == 1)
    {
        for (int i = 0; i < row; i++)
        {
            uchar* p = dst_tmp.ptr(i);
            float y = i * y_a;


            for (int j = 0; j < col; j++)
            {
                float x = j * x_a;


                p[j] = line_inner(src, x, y);


            }
        }
    }
    else if (inner_type == 2)
    {
        for (int i = 0; i < row; i++)
        {
            uchar* p = dst_tmp.ptr(i);
            float y = i * y_a;


            for (int j = 0; j < col; j++)
            {
                float x = j * x_a;


                p[j] = cubic_inner(src, x, y, -0.5);


            }
        }
    }
    else
    {
        for (int i = 0; i < row; i++)
        {
            uchar* p = dst_tmp.ptr(i);
            float y = i * y_a;


            for (int j = 0; j < col; j++)
            {
                float x = j * x_a;


                p[j] = bpline_inner(src, x, y);


            }
        }
    }


    dst_tmp.copyTo(dst);
}


//测试函数,调用以上图像缩放,并显示结果
void resize_img_test(void)
{
    Mat img = imread("image/lena.png", CV_LOAD_IMAGE_GRAYSCALE);


    float mul = 3.0;  //宽和高的放大倍数都为3


    Mat img_resize_nearst, img_resize_line, img_resize_cubic, img_resize_bpline;


    resize_img(img, img_resize_nearst, mul, mul, 0);
    resize_img(img, img_resize_line, mul, mul, 1);
    resize_img(img, img_resize_cubic, mul, mul, 2);
    resize_img(img, img_resize_bpline, mul, mul, 3);
        


    imshow("img", img);
    imshow("img_resize_nearst", img_resize_nearst);  //最近邻
    imshow("img_resize_line", img_resize_line);  //双线性
    imshow("img_resize_cubic", img_resize_cubic);   //双三次
    imshow("img_resize_bpline", img_resize_bpline);  //三次B样条
    waitKey();
}

运行以上代码,分别使用几种插值算法对Lena的宽、高都放大3倍,得到结果如下:

图像的三次B样条插值原理与C++实现_第11张图片

原图

图像的三次B样条插值原理与C++实现_第12张图片

最近邻插值

图像的三次B样条插值原理与C++实现_第13张图片

双线性插值

图像的三次B样条插值原理与C++实现_第14张图片

双三次插值

图像的三次B样条插值原理与C++实现_第15张图片

三次B样条插值

由以上结果可知放大图像之后:

  • 马赛克现象:最近邻插值>双线性插值≥双三次插值>三次B样条插值

  • 边缘锯齿现象:最近邻插值>双线性插值≥双三次插值>三次B样条插值

  • 插值后模糊度:最近邻插值<双线性插值≤双三次插值<三次B样条插值

为了对比更明显一点,我们把Lena图像中帽子边缘区域截取出来对比:

图像的三次B样条插值原理与C++实现_第16张图片

微信公众号如下,会不定期更新精彩内容,欢迎关注:

你可能感兴趣的:(图像配准,Opencv,C++编程,计算机视觉,opencv,B样条插值,图像配准,C++)