实现任意改变图像尺寸--双线插值法

	//输入：图像
    //输出：指定的图像尺寸 change_ysize==rows;change_xsize==cols
    Mat Change_Size(Mat image,int change_ysize, int change_xsize)
    {
        float xscale = (change_xsize * 1.0)/(image.cols * 1.0);
        float yscale = (change_ysize * 1.0)/(image.rows * 1.0);
        int i, j;
        int xleft, xright, ylow, yheight;
        uchar* data;
        float xd, yd;
        Mat out_image;
        if (image.channels() == 1)
            out_image = Mat::zeros(change_ysize, change_xsize, CV_8UC1);
        else if (image.channels() == 3)
            out_image = Mat::zeros(change_ysize, change_xsize, CV_8UC3);
        else;
        cout << out_image.channels() << endl;
        if (image.channels() == 1)
        {
            //Mat out_image(change_xsize, change_ysize, CV_8UC1);
            for (i = 0; i < change_ysize; ++i)
            {
                data = out_image.ptr<uchar>(i);
                for (j = 0; j < change_xsize; ++j)
                {
                    //输出图像坐标对应于输入图像坐标
                    ylow = (int)(i * 1.0 / yscale);
                    yheight = ylow + 1;
                    xleft = (int)(j * 1.0 / xscale);
                    xright = xleft + 1;
                    xd = (j * 1.0 / xscale) - xleft;
                    yd = (i * 1.0 / yscale) - ylow;
                    //寻找灰度值
                    uchar value00 = image.ptr<uchar>(ylow)[xleft];
                    uchar value01 = image.ptr<uchar>(ylow)[xright];
                    uchar value10 = image.ptr<uchar>(yheight)[xleft];
                    uchar value11 = image.ptr<uchar>(yheight)[xright];
                    //灰度值计算
                    data[j] = (1-xd) *(1-yd) * value00 + (1 - xd) * yd * value01 + xd * (1 - yd) * value10 + xd * yd * value11;
                }
            }
        }
        else if (image.channels() == 3)
        {
            //Mat out_image(change_xsize, change_ysize, CV_8UC3);
            for (i = 0; i < change_ysize; ++i)
            {
                for (j = 0; j < change_xsize; ++j)
                {
                    //输出图像坐标对应于输入图像坐标
                    ylow = (int)(i * 1.0 / yscale);
                    yheight = ylow + 1;
                    xleft = (int)(j * 1.0 / xscale);
                    xright = xleft + 1;
                    //寻找坐标
                    if (xright >= image.cols)
                        xright = image.cols-1;
                    if (yheight >= image.rows)
                        yheight = image.rows - 1;
                    Vec3b index00 = image.at<Vec3b>(ylow, xleft);
                    Vec3b index01 = image.at<Vec3b>(ylow, xright);
                    Vec3b index10 = image.at<Vec3b>(yheight, xleft);
                    Vec3b index11 = image.at<Vec3b>(yheight, xright);
                    //比例
                    xd = (j * 1.0 / xscale) - xleft;
                    yd = (i * 1.0 / yscale) - ylow;
                    //计算
                    out_image.at<Vec3b>(i, j)[0] = xd * yd * index00[0] + (1 - xd) * yd * index01[0] + xd * (1 - yd) * index10[0] + (1 - xd) * (1 - yd) * index11[0];
                    out_image.at<Vec3b>(i, j)[1] = xd * yd * index00[1] + (1 - xd) * yd * index01[1] + xd * (1 - yd) * index10[1] + (1 - xd) * (1 - yd) * index11[1];
                    out_image.at<Vec3b>(i, j)[2] = xd * yd * index00[2] + (1 - xd) * yd * index01[2] + xd * (1 - yd) * index10[2] + (1 - xd) * (1 - yd) * index11[2];
                }
            }
        }
        else;
        return out_image;
    }