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<opencv2\core\core.hpp>
#include<opencv2\highgui\highgui.hpp>
#include<opencv2\imgproc\imgproc.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...\n");
        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