4.1 图像采样

4.1.1 最近邻插值

最简单图像缩放方法，原理：提取源数据图像中与其邻域最近像素值来作为目标图像相对应点的像素值。

目标各像素点的灰度值-->源图像中与其最邻近像素的灰度值。 

OpenCV中提供3个将浮点型数转换成整数的函数：cvRound/cvFloor/cvCeil

////////https://blog.csdn.net/linqianbi/article/details/78593724
////////https://blog.csdn.net/qq_22424571/article/details/80918549
#include<opencv2corecore.hpp>
#include<opencv2highguihighgui.hpp>
#include<opencv2imgprocimgproc.hpp>
#include<iostream>
using namespace cv;
//最近邻插值
//基于等间隔提取图像的缩放
Mat imageReduction1(Mat &srcImage, float kx, float ky)//原始图形以及缩放比例
{
    //获取输出图像分辨率
    int nRows = cvRound(srcImage.rows * kx);//cvRound这个函数返回的是和参数最接近的整数
    int nCols = cvRound(srcImage.cols * ky);
    Mat resultImage(nRows, nCols, srcImage.type());//创建一张输出的图像
    for (int i = 0; i < nRows; i++)
    {
        //根据水平因子计算在原图中的坐标
        int x = static_cast<int>((i + 1) / kx + 0.5) - 1;
        for (int j = 0; j < nCols; j++)
        {
            //根据垂直因子计算在原图中的坐标
            int y = static_cast<int>((j + 1) / ky + 0.5) - 1;
            resultImage.at<Vec3b>(i, j) = srcImage.at<Vec3b>(x, y);
        }
    }
    return resultImage;
}

//基于区域子块提取图像缩放
//求每个区域子块中的像素的通道的平均值
Vec3b areaAverage(Mat &srcImage, Point_<int> leftPoint, Point_<int> rightPoint)
{
    int temp1 = 0, temp2 = 0, temp3 = 0;//用来保存区域块中的每个通道像素的和
                                        //计算区域块中的像素点的个数
    int nPix = (rightPoint.x - leftPoint.x + 1)*(rightPoint.y - leftPoint.y + 1);
    //计算区域子块中的各个通道的像素和
    for (int i = leftPoint.x; i <= rightPoint.x; i++)
    {
        for (int j = leftPoint.y; j <= rightPoint.y; j++)
        {
            temp1 += srcImage.at<Vec3b>(i, j)[0];//求和区域块中的蓝绿红通道的像素和
            temp2 += srcImage.at<Vec3b>(i, j)[1];
            temp3 += srcImage.at<Vec3b>(i, j)[2];
        }
    }
    //对区域块中的每个通道求平均值
    Vec3b vecTemp;
    vecTemp[0] = temp1 / nPix;
    vecTemp[1] = temp2 / nPix;
    vecTemp[2] = temp3 / nPix;
    return vecTemp;
}

Mat imageReduction2(Mat &srcImage, float kx, float ky)
{
    //获取输出图像分辨率
    int nRows = cvRound(srcImage.rows * kx);//cvRound这个函数返回的是和参数最接近的整数
    int nCols = cvRound(srcImage.cols * ky);
    Mat resultImage(nRows, nCols, srcImage.type());//创建一张输出的图像
                                                   //区域子块的左上角行列坐标
    int leftRowcoordinate = 0;
    int leftColcoordinate = 0;

    for (int i = 0; i < nRows; i++)
    {
        //根据水平因子计算在原图中的坐标
        int x = static_cast<int>((i + 1) / kx + 0.5) - 1;
        for (int j = 0; j < nCols; j++)
        {
            //根据垂直因子计算在原图中的坐标
            int y = static_cast<int>((j + 1) / ky + 0.5) - 1;
            //求区域子块的均值
            resultImage.at<Vec3b>(i, j) = areaAverage(srcImage, Point_<int>(leftRowcoordinate, leftColcoordinate), Point_<int>(x, y));
            //更新下子块左上角的列坐标，行坐标不变
            leftColcoordinate = y + 1;
        }
        //一列循环完毕重新将列坐标置零
        leftColcoordinate = 0;
        //更新下子块左上角的行坐标
        leftRowcoordinate = x + 1;
    }
    return resultImage;

}


int main()
{
    Mat srcIamge = imread("D:\大海.jpg");
    if (!srcIamge.data)
    {
        printf("image could not load...
");
        return -1;
    }
    imshow("srcIamge", srcIamge);
    Mat resultImage1 = imageReduction1(srcIamge, 0.5, 0.5);
    imshow("res1", resultImage1);

    Mat resultImage2 = imageReduction2(srcIamge, 0.5, 0.5);
    imshow("res2", resultImage2);
    waitKey(0);
    return 0;

}

参考：

https://blog.csdn.net/linqianbi/article/details/78593724
https://blog.csdn.net/qq_22424571/article/details/80918549

https://blog.csdn.net/gbyy42299/article/details/80406509

　　这是一种最基本、最简单的图像缩放算法，效果也是最不好的，放大后的图像有很严重的马赛克，缩小后的图像有很严重的失真；效果不好的根源就是其简单的最临近插值方法引入了严重的图像失真，比如，当由目标图的坐标反推得到的源图的的坐标是一个浮点数的时候，采用了四舍五入的方法，直接采用了和这个浮点数最接近的象素的值，这种方法是很不科学的，当推得坐标值为 0.75的时候，不应该就简单的取为1，既然是0.75，比1要小0.25 ，比0要大0.75 ,那么目标象素值其实应该根据这个源图中虚拟的点四周的四个真实的点来按照一定的规律计算出来的，这样才能达到更好的缩放效果。
　　双线型内插值算法就是一种比较好的图像缩放算法，它充分的利用了源图中虚拟点四周的四个真实存在的像素值来共同决定目标图中的一个像素值，因此缩放效果比简单的最邻近插值要好很多。 

4.1.2 双线性插值

////////https://blog.csdn.net/Gone_HuiLin/article/details/53223222
#include <opencv2/imgproc/imgproc.hpp>  
#include <opencv2/core/core.hpp>        
#include <opencv2/highgui/highgui.hpp> 
#include <iostream> 
// 实现双线性插值图像缩放
cv::Mat BilinearInterpolation(cv::Mat srcImage)
{
    CV_Assert(srcImage.data != NULL);
    int srcRows = srcImage.rows;
    int srcCols = srcImage.cols;
    int srcStep = srcImage.step;
    // 构建目标图像
    cv::Mat dstImage = cv::Mat(
        cv::Size(640, 480), srcImage.type(),
        cv::Scalar::all(0));
    int dstRows = dstImage.rows;
    int dstCols = dstImage.cols;
    int dstStep = dstImage.step;
    // 数据定义及转换
    IplImage src = srcImage;
    IplImage dst = dstImage;
    std::cout << "srcCols:" << srcCols << " srcRows:" <<
        srcRows << "srcStep:" << srcStep << std::endl;
    std::cout << "dstCols:" << dstCols << " dstRows:" <<
        dstRows << "dstStep:" << dstStep << std::endl;
    // 坐标定义
    float srcX = 0, srcY = 0;
    float t1X = 0, t1Y = 0, t1Z = 0;
    float t2X = 0, t2Y = 0, t2Z = 0;
    for (int j = 0; j < dstRows - 1; j++)
    {
        for (int i = 0; i < dstCols - 1; i++)
        {
            // 缩放映射关系 
            srcX = (i + 0.5)*((float)srcCols) / (dstCols)-0.5;
            srcY = (j + 0.5)*((float)srcRows) / (dstRows)-0.5;
            int iSrcX = (int)srcX;
            int iSrcY = (int)srcY;
            // 三通道求邻域加权值1
            t1X = ((uchar*)(src.imageData + srcStep*iSrcY))[
                iSrcX * 3 + 0] * (1 - std::abs(srcX - iSrcX)) +
                    ((uchar*)(src.imageData + srcStep*iSrcY))[
                        (iSrcX + 1) * 3 + 0] * (srcX - iSrcX);
            t1Y = ((uchar*)(src.imageData + srcStep*iSrcY))[
                iSrcX * 3 + 1] * (1 - std::abs(srcX - iSrcX)) +
                    ((uchar*)(src.imageData + srcStep*iSrcY))[
                        (iSrcX + 1) * 3 + 1] * (srcX - iSrcX);
            t1Z = ((uchar*)(src.imageData + srcStep*iSrcY))[
                iSrcX * 3 + 2] * (1 - std::abs(srcX - iSrcX)) +
                    ((uchar*)(src.imageData + srcStep*iSrcY))[
                        (iSrcX + 1) * 3 + 2] * (srcX - iSrcX);
            // 三通道求邻域加权值2
            t2X = ((uchar*)(src.imageData + srcStep*(
                iSrcY + 1)))[iSrcX * 3] * (1 - std::abs(srcX - iSrcX))
                + ((uchar*)(src.imageData + srcStep*(
                    iSrcY + 1)))[(iSrcX + 1) * 3] * (srcX - iSrcX);
            t2Y = ((uchar*)(src.imageData + srcStep*(
                iSrcY + 1)))[iSrcX * 3 + 1] * (1 - std::abs(srcX - iSrcX))
                + ((uchar*)(src.imageData + srcStep*(
                    iSrcY + 1)))[(iSrcX + 1) * 3 + 1] * (srcX - iSrcX);
            t2Z = ((uchar*)(src.imageData + srcStep*(
                iSrcY + 1)))[iSrcX * 3 + 2] * (1 - std::abs(srcX - iSrcX))
                + ((uchar*)(src.imageData + srcStep*(iSrcY + 1)))[(
                    iSrcX + 1) * 3 + 2] * (srcX - iSrcX);
            // 根据公式求解目标图像加权
            ((uchar*)(dst.imageData + dstStep*j))[i * 3] =
                t1X*(1 - std::abs(srcY - iSrcY)) + t2X*(
                    std::abs(srcY - iSrcY));
            ((uchar*)(dst.imageData + dstStep*j))[i * 3 + 1] =
                t1Y*(1 - std::abs(srcY - iSrcY)) + t2Y*(
                    std::abs(srcY - iSrcY));
            ((uchar*)(dst.imageData + dstStep*j))[i * 3 + 2] =
                t1Z*(1 - std::abs(srcY - iSrcY)) + t2Z*(
                    std::abs(srcY - iSrcY));
        }
        // 列操作
        ((uchar*)(dst.imageData + dstStep*j))[(dstCols - 1) * 3] =
            ((uchar*)(dst.imageData + dstStep*j))[(dstCols - 2) * 3];
        ((uchar*)(dst.imageData + dstStep*j))[(dstCols - 1) * 3 +
            1] = ((uchar*)(dst.imageData + dstStep*j))[(
                dstCols - 2) * 3 + 1];
        ((uchar*)(dst.imageData + dstStep*j))[(dstCols - 1) * 3
            + 2] = ((uchar*)(dst.imageData + dstStep*j))[(
                dstCols - 2) * 3 + 2];
    }
    // 行操作
    for (int i = 0; i < dstCols * 3; i++)
    {
        ((uchar*)(dst.imageData + dstStep*(dstRows - 1)))[i] =
            ((uchar*)(dst.imageData + dstStep*(dstRows - 2)))[i];
    }
    return  dstImage;
}

int main()
{
    cv::Mat srcImage = cv::imread("D:\大海.jpg");
    if (!srcImage.data)
        return -1;
    cv::Mat dstImage = BilinearInterpolation(srcImage);
    cv::imshow("srcImage", srcImage);
    cv::imshow("dstImage", dstImage);
    cv::waitKey(0);
    return 0;
}

参考：

https://www.cnblogs.com/yssongest/p/5303151.html

4.1.3 插值操作性能对比

//////////https://blog.csdn.net/spw_1201/article/details/53544014
//////////最邻近、双线性、基于像素区域、立方插值及兰索斯插值
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
using namespace cv;
using namespace std;
void ResizeExample(Mat srcImage)
{
    //判断输入有效性
    CV_Assert(srcImage.data != NULL);
    imshow("srcImage", srcImage);
    Mat dstImage(256, 256, CV_8UC3);
    //测试1：默认参数为双线性插值
    double tTime;
    tTime = (double)getTickCount();
    const int nTimes = 100;
    for (int i = 0; i < nTimes; i++)
    {
        resize(srcImage, dstImage, dstImage.size(), 0, 0);
    }
    tTime = 1000 * ((double)getTickCount() - tTime) / getTickFrequency();
    tTime /= nTimes;
    cout << "text1: " << tTime << endl;
    imshow("1 default parameters:dstImage", dstImage);
    //测试2：最邻近插值
    tTime = (double)getTickCount();

    for (int i = 0; i < nTimes; i++)
    {
        resize(srcImage, dstImage, Size(256, 256), 0, 0, INTER_NEAREST);
    }
    tTime = 1000 * ((double)getTickCount() - tTime) / getTickFrequency();
    tTime /= nTimes;
    cout << "text2: " << tTime << endl;
    imshow("2 INTER_NEAREST:dstImage", dstImage);
    //测试3：像素区域插值
    tTime = (double)getTickCount();

    for (int i = 0; i < nTimes; i++)
    {
        resize(srcImage, dstImage, Size(256, 256), 0.5, 0.5, INTER_AREA);
    }
    tTime = 1000 * ((double)getTickCount() - tTime) / getTickFrequency();
    tTime /= nTimes;
    cout << "text3: " << tTime << endl;
    imshow("3 INTER_AREA : dstImage", dstImage);
    //测试4：三次插值
    tTime = (double)getTickCount();

    for (int i = 0; i < nTimes; i++)
    {
        resize(srcImage, dstImage, Size(), 0.5, 0.5, INTER_CUBIC);
    }
    tTime = 1000 * ((double)getTickCount() - tTime) / getTickFrequency();
    tTime /= nTimes;
    cout << "text4: " << tTime << endl;
    imshow("4 INTER_CUBIC : dstImage", dstImage);
    //测试5：三次插值
    tTime = (double)getTickCount();

    for (int i = 0; i < nTimes; i++)
    {
        resize(srcImage, dstImage, Size(), 0.5, 0.5, INTER_LANCZOS4);
    }
    tTime = 1000 * ((double)getTickCount() - tTime) / getTickFrequency();
    tTime /= nTimes;
    cout << "text5: " << tTime << endl;
    imshow("5 INTER_LANCZOS4 : dstImage", dstImage);
}
int main()
{
    Mat srcImage = imread("D:\大海.jpg");
    if (!srcImage.data)
        return -1;
    ResizeExample(srcImage);
    waitKey(0);
    return 0;
}

4.1.4图像金字塔

其实非常好理解，如上图所示，我们将一层层的图像比喻为金字塔，层级越高，则图像尺寸越小，分辨率越低。

两种类型的金字塔：

• 高斯金字塔：用于下采样，主要的图像金字塔；
• 拉普拉斯金字塔：用于重建图像，也就是预测残差（我的理解是，因为小图像放大，必须插入一些像素值，那这些像素值是什么才合适呢，那就得进行根据周围像素进行预测），对图像进行最大程度的还原。比如一幅小图像重建为一幅大图像，

图像金字塔有两个高频出现的名词：上采样和下采样。现在说说他们俩。

• 上采样：就是图片放大（所谓上嘛，就是变大），使用PryUp函数
• 下采样：就是图片缩小（所谓下嘛，就是变小），使用PryDown函数

下采样将步骤：

1. 对图像进行高斯内核卷积
2. 将所有偶数行和列去除

下采样就是图像压缩，会丢失图像信息。

上采样步骤：

1. 将图像在每个方向放大为原来的两倍，新增的行和列用0填充；
2. 使用先前同样的内核（乘以4）与放大后的图像卷积，获得新增像素的近似值。

函数 cv2.pyrDown() 从一个高分辨率大尺寸的图像向上构建一个金字塔（尺寸变小，分辨率降低）。

函数 cv2.pyrUp() 从一个低分辨率小尺寸的图像向下构建一个金子塔（尺寸变大，但分辨率不会)

图像金字塔的一个应用是图像融合。例如，在图像缝合中，你需要将两幅图叠在一起，但是由于连接区域图像像素的不连续性，整幅图的效果看起来会很差，这时图像金字塔就可以排上用场了，可以实现无缝连接。 

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

using namespace std;
using namespace cv;

int main()
{
    Mat srcImage = imread("D:\大海.jpg");

    //判断图像是否加载成功
    if (srcImage.empty())
    {
        cout << "图像加载失败!" << endl;
        return -1;
    }
    else
        cout << "图像加载成功!" << endl << endl;

    namedWindow("原图像", WINDOW_AUTOSIZE);
    imshow("原图像", srcImage);

    //两次向下采样操作分别输出
    Mat pyrDownImage_1, pyrDownImage_2;

    pyrDown(srcImage, pyrDownImage_1);
    namedWindow("向下采样-1", WINDOW_AUTOSIZE);
    imshow("向下采样-1", pyrDownImage_1);

    pyrDown(pyrDownImage_1, pyrDownImage_2);
    namedWindow("向下采样-2", WINDOW_AUTOSIZE);
    imshow("向下采样-2", pyrDownImage_2);

    //利用向下采样的结果进行向上采样操作
    Mat pyrUpImage_1, pyrUpImage_2;

    pyrUp(pyrDownImage_2, pyrUpImage_1);
    namedWindow("向上采样-1", WINDOW_AUTOSIZE);
    imshow("向上采样-1", pyrUpImage_1);

    pyrUp(pyrUpImage_1, pyrUpImage_2);
    namedWindow("向上采样-2", WINDOW_AUTOSIZE);
    imshow("向上采样-2", pyrUpImage_2);

    waitKey(0);

    return 0;
}

 https://blog.csdn.net/u010682375/article/details/70147508

https://www.cnblogs.com/skyfsm/p/6876732.html

https://blog.csdn.net/keith_bb/article/details/54583514

https://blog.csdn.net/lindazhu520/article/details/72596672