2. 程式人生 > >OpenCV探索之路（二十四）影象拼接和影象融合技術

OpenCV探索之路（二十四）影象拼接和影象融合技術

阿新 • • 發佈：2019-01-06

影象拼接在實際的應用場景很廣，比如無人機航拍，遙感影象等等，影象拼接是進一步做影象理解基礎步驟，拼接效果的好壞直接影響接下來的工作，所以一個好的影象拼接演算法非常重要。

再舉一個身邊的例子吧，你用你的手機對某一場景拍照，但是你沒有辦法一次將所有你要拍的景物全部拍下來，所以你對該場景從左往右依次拍了好幾張圖，來把你要拍的所有景物記錄下來。那麼我們能不能把這些影象拼接成一個大圖呢？我們利用opencv就可以做到影象拼接的效果！

比如我們有對這兩張圖進行拼接。

1093303-20170822154321308-71491510.png

從上面兩張圖可以看出，這兩張圖有比較多的重疊部分，這也是拼接的基本要求。

那麼要實現影象拼接需要那幾步呢？簡單來說有以下幾步：

  1. 對每幅圖進行特徵點提取
  2. 對對特徵點進行匹配
  3. 進行影象配準
  4. 把影象拷貝到另一幅影象的特定位置
  5. 對重疊邊界進行特殊處理

好吧，那就開始正式實現影象配準。

第一步就是特徵點提取。現在CV領域有很多特徵點的定義，比如sift、surf、harris角點、ORB都是很有名的特徵因子，都可以用來做影象拼接的工作，他們各有優勢。本文將使用ORB和SURF進行影象拼接，用其他方法進行拼接也是類似的。

基於SURF的影象拼接

用SIFT演算法來實現影象拼接是很常用的方法，但是因為SIFT計算量很大，所以在速度要求很高的場合下不再適用。所以，它的改進方法SURF因為在速度方面有了明顯的提高（速度是SIFT的3倍），所以在影象拼接領域還是大有作為。雖說SURF精確度和穩定性不及SIFT，但是其綜合能力還是優越一些。下面將詳細介紹拼接的主要步驟。

1.特徵點提取和匹配

特徵點提取和匹配的方法我在上一篇文章《OpenCV探索之路（二十三）：特徵檢測和特徵匹配方法彙總》中做了詳細的介紹，在這裡直接使用上文所總結的SURF特徵提取和特徵匹配的方法。

//提取特徵點    
SurfFeatureDetector Detector(2000);  
vector<KeyPoint> keyPoint1, keyPoint2;
Detector.detect(image1, keyPoint1);
Detector.detect(image2, keyPoint2);

//特徵點描述，為下邊的特徵點匹配做準備    
SurfDescriptorExtractor Descriptor;
Mat imageDesc1, imageDesc2;
Descriptor.compute(image1, keyPoint1, imageDesc1);
Descriptor.compute(image2, keyPoint2, imageDesc2);

FlannBasedMatcher matcher;
vector<vector<DMatch> > matchePoints;
vector<DMatch> GoodMatchePoints;

vector<Mat> train_desc(1, imageDesc1);
matcher.add(train_desc);
matcher.train();

matcher.knnMatch(imageDesc2, matchePoints, 2);
cout << "total match points: " << matchePoints.size() << endl;

// Lowe's algorithm,獲取優秀匹配點
for (int i = 0; i < matchePoints.size(); i++)
{
    if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
    {
        GoodMatchePoints.push_back(matchePoints[i][0]);
    }
}

Mat first_match;
drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
imshow("first_match ", first_match);

1093303-20170822154344449-509144423.png

2.影象配準

這樣子我們就可以得到了兩幅待拼接圖的匹配點集，接下來我們進行影象的配準，即將兩張影象轉換為同一座標下，這裡我們需要使用findHomography函式來求得變換矩陣。但是需要注意的是，findHomography函式所要用到的點集是Point2f型別的，所有我們需要對我們剛得到的點集GoodMatchePoints再做一次處理，使其轉換為Point2f型別的點集。

vector<Point2f> imagePoints1, imagePoints2;

for (int i = 0; i<GoodMatchePoints.size(); i++)
{
    imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
    imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
}

這樣子，我們就可以拿著imagePoints1, imagePoints2去求變換矩陣了，並且實現影象配準。值得注意的是findHomography函式的引數中我們選澤了CV_RANSAC，這表明我們選擇RANSAC演算法繼續篩選可靠地匹配點，這使得匹配點解更為精確。

//獲取影象1到影象2的投影對映矩陣 尺寸為3*3  
Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
////也可以使用getPerspectiveTransform方法獲得透視變換矩陣，不過要求只能有4個點，效果稍差  
//Mat   homo=getPerspectiveTransform(imagePoints1,imagePoints2);  
cout << "變換矩陣為：\n" << homo << endl << endl; //輸出對映矩陣     

//影象配準  
Mat imageTransform1, imageTransform2;
warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
//warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
imshow("直接經過透視矩陣變換", imageTransform1);
imwrite("trans1.jpg", imageTransform1);

1093303-20170822154403277-379911836.png

3. 影象拷貝

拷貝的思路很簡單，就是將左圖直接拷貝到配準圖上就可以了。

//建立拼接後的圖,需提前計算圖的大小
int dst_width = imageTransform1.cols;  //取最右點的長度為拼接圖的長度
int dst_height = image02.rows;

Mat dst(dst_height, dst_width, CV_8UC3);
dst.setTo(0);

imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));

imshow("b_dst", dst);

1093303-20170822154425449-1866547572.png

4.影象融合（去裂縫處理）

從上圖可以看出，兩圖的拼接並不自然，原因就在於拼接圖的交界處，兩圖因為光照色澤的原因使得兩圖交界處的過渡很糟糕，所以需要特定的處理解決這種不自然。這裡的處理思路是加權融合，在重疊部分由前一幅影象慢慢過渡到第二幅影象，即將影象的重疊區域的畫素值按一定的權值相加合成新的影象。


//優化兩圖的連線處，使得拼接自然
void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
{
    int start = MIN(corners.left_top.x, corners.left_bottom.x);//開始位置，即重疊區域的左邊界  

    double processWidth = img1.cols - start;//重疊區域的寬度  
    int rows = dst.rows;
    int cols = img1.cols; //注意，是列數*通道數
    double alpha = 1;//img1中畫素的權重  
    for (int i = 0; i < rows; i++)
    {
        uchar* p = img1.ptr<uchar>(i);  //獲取第i行的首地址
        uchar* t = trans.ptr<uchar>(i);
        uchar* d = dst.ptr<uchar>(i);
        for (int j = start; j < cols; j++)
        {
            //如果遇到影象trans中無畫素的黑點，則完全拷貝img1中的資料
            if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
            {
                alpha = 1;
            }
            else
            {
                //img1中畫素的權重，與當前處理點距重疊區域左邊界的距離成正比，實驗證明，這種方法確實好  
                alpha = (processWidth - (j - start)) / processWidth;
            }

            d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
            d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
            d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);

        }
    }

}

1093303-20170822154445464-413726039.png

多嘗試幾張，驗證拼接效果

測試一

1093303-20170822154454839-1253938282.png

1093303-20170822154506605-1380482375.png

測試二

1093303-20170822154518449-1425129916.png

1093303-20170822154535324-2137232231.png

測試三

1093303-20170822154551746-1673577698.png

1093303-20170822154603746-881176266.png

最後給出完整的SURF演算法實現的拼接程式碼。

#include "highgui/highgui.hpp"    
#include "opencv2/nonfree/nonfree.hpp"    
#include "opencv2/legacy/legacy.hpp"   
#include <iostream>  

using namespace cv;
using namespace std;

void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);

typedef struct
{
    Point2f left_top;
    Point2f left_bottom;
    Point2f right_top;
    Point2f right_bottom;
}four_corners_t;

four_corners_t corners;

void CalcCorners(const Mat& H, const Mat& src)
{
    double v2[] = { 0, 0, 1 };//左上角
    double v1[3];//變換後的座標值
    Mat V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    Mat V1 = Mat(3, 1, CV_64FC1, v1);  //列向量

    V1 = H * V2;
    //左上角(0,0,1)
    cout << "V2: " << V2 << endl;
    cout << "V1: " << V1 << endl;
    corners.left_top.x = v1[0] / v1[2];
    corners.left_top.y = v1[1] / v1[2];

    //左下角(0,src.rows,1)
    v2[0] = 0;
    v2[1] = src.rows;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.left_bottom.x = v1[0] / v1[2];
    corners.left_bottom.y = v1[1] / v1[2];

    //右上角(src.cols,0,1)
    v2[0] = src.cols;
    v2[1] = 0;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.right_top.x = v1[0] / v1[2];
    corners.right_top.y = v1[1] / v1[2];

    //右下角(src.cols,src.rows,1)
    v2[0] = src.cols;
    v2[1] = src.rows;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.right_bottom.x = v1[0] / v1[2];
    corners.right_bottom.y = v1[1] / v1[2];

}

int main(int argc, char *argv[])
{
    Mat image01 = imread("g5.jpg", 1);    //右圖
    Mat image02 = imread("g4.jpg", 1);    //左圖
    imshow("p2", image01);
    imshow("p1", image02);

    //灰度圖轉換  
    Mat image1, image2;
    cvtColor(image01, image1, CV_RGB2GRAY);
    cvtColor(image02, image2, CV_RGB2GRAY);


    //提取特徵點    
    SurfFeatureDetector Detector(2000);  
    vector<KeyPoint> keyPoint1, keyPoint2;
    Detector.detect(image1, keyPoint1);
    Detector.detect(image2, keyPoint2);

    //特徵點描述，為下邊的特徵點匹配做準備    
    SurfDescriptorExtractor Descriptor;
    Mat imageDesc1, imageDesc2;
    Descriptor.compute(image1, keyPoint1, imageDesc1);
    Descriptor.compute(image2, keyPoint2, imageDesc2);

    FlannBasedMatcher matcher;
    vector<vector<DMatch> > matchePoints;
    vector<DMatch> GoodMatchePoints;

    vector<Mat> train_desc(1, imageDesc1);
    matcher.add(train_desc);
    matcher.train();

    matcher.knnMatch(imageDesc2, matchePoints, 2);
    cout << "total match points: " << matchePoints.size() << endl;

    // Lowe's algorithm,獲取優秀匹配點
    for (int i = 0; i < matchePoints.size(); i++)
    {
        if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
        {
            GoodMatchePoints.push_back(matchePoints[i][0]);
        }
    }

    Mat first_match;
    drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
    imshow("first_match ", first_match);

    vector<Point2f> imagePoints1, imagePoints2;

    for (int i = 0; i<GoodMatchePoints.size(); i++)
    {
        imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
        imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
    }



    //獲取影象1到影象2的投影對映矩陣 尺寸為3*3  
    Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
    ////也可以使用getPerspectiveTransform方法獲得透視變換矩陣，不過要求只能有4個點，效果稍差  
    //Mat   homo=getPerspectiveTransform(imagePoints1,imagePoints2);  
    cout << "變換矩陣為：\n" << homo << endl << endl; //輸出對映矩陣      

   //計算配準圖的四個頂點座標
    CalcCorners(homo, image01);
    cout << "left_top:" << corners.left_top << endl;
    cout << "left_bottom:" << corners.left_bottom << endl;
    cout << "right_top:" << corners.right_top << endl;
    cout << "right_bottom:" << corners.right_bottom << endl;

    //影象配準  
    Mat imageTransform1, imageTransform2;
    warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
    //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
    imshow("直接經過透視矩陣變換", imageTransform1);
    imwrite("trans1.jpg", imageTransform1);


    //建立拼接後的圖,需提前計算圖的大小
    int dst_width = imageTransform1.cols;  //取最右點的長度為拼接圖的長度
    int dst_height = image02.rows;

    Mat dst(dst_height, dst_width, CV_8UC3);
    dst.setTo(0);

    imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
    image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));

    imshow("b_dst", dst);


    OptimizeSeam(image02, imageTransform1, dst);


    imshow("dst", dst);
    imwrite("dst.jpg", dst);

    waitKey();

    return 0;
}


//優化兩圖的連線處，使得拼接自然
void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
{
    int start = MIN(corners.left_top.x, corners.left_bottom.x);//開始位置，即重疊區域的左邊界  

    double processWidth = img1.cols - start;//重疊區域的寬度  
    int rows = dst.rows;
    int cols = img1.cols; //注意，是列數*通道數
    double alpha = 1;//img1中畫素的權重  
    for (int i = 0; i < rows; i++)
    {
        uchar* p = img1.ptr<uchar>(i);  //獲取第i行的首地址
        uchar* t = trans.ptr<uchar>(i);
        uchar* d = dst.ptr<uchar>(i);
        for (int j = start; j < cols; j++)
        {
            //如果遇到影象trans中無畫素的黑點，則完全拷貝img1中的資料
            if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
            {
                alpha = 1;
            }
            else
            {
                //img1中畫素的權重，與當前處理點距重疊區域左邊界的距離成正比，實驗證明，這種方法確實好  
                alpha = (processWidth - (j - start)) / processWidth;
            }

            d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
            d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
            d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);

        }
    }

}

基於ORB的影象拼接

利用ORB進行影象拼接的思路跟上面的思路基本一樣，只是特徵提取和特徵點匹配的方式略有差異罷了。這裡就不再詳細介紹思路了，直接貼程式碼看效果。

#include "highgui/highgui.hpp"    
#include "opencv2/nonfree/nonfree.hpp"    
#include "opencv2/legacy/legacy.hpp"   
#include <iostream>  

using namespace cv;
using namespace std;

void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);

typedef struct
{
    Point2f left_top;
    Point2f left_bottom;
    Point2f right_top;
    Point2f right_bottom;
}four_corners_t;

four_corners_t corners;

void CalcCorners(const Mat& H, const Mat& src)
{
    double v2[] = { 0, 0, 1 };//左上角
    double v1[3];//變換後的座標值
    Mat V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    Mat V1 = Mat(3, 1, CV_64FC1, v1);  //列向量

    V1 = H * V2;
    //左上角(0,0,1)
    cout << "V2: " << V2 << endl;
    cout << "V1: " << V1 << endl;
    corners.left_top.x = v1[0] / v1[2];
    corners.left_top.y = v1[1] / v1[2];

    //左下角(0,src.rows,1)
    v2[0] = 0;
    v2[1] = src.rows;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.left_bottom.x = v1[0] / v1[2];
    corners.left_bottom.y = v1[1] / v1[2];

    //右上角(src.cols,0,1)
    v2[0] = src.cols;
    v2[1] = 0;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.right_top.x = v1[0] / v1[2];
    corners.right_top.y = v1[1] / v1[2];

    //右下角(src.cols,src.rows,1)
    v2[0] = src.cols;
    v2[1] = src.rows;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.right_bottom.x = v1[0] / v1[2];
    corners.right_bottom.y = v1[1] / v1[2];

}

int main(int argc, char *argv[])
{
    Mat image01 = imread("t1.jpg", 1);    //右圖
    Mat image02 = imread("t2.jpg", 1);    //左圖
    imshow("p2", image01);
    imshow("p1", image02);

    //灰度圖轉換  
    Mat image1, image2;
    cvtColor(image01, image1, CV_RGB2GRAY);
    cvtColor(image02, image2, CV_RGB2GRAY);


    //提取特徵點    
    OrbFeatureDetector  surfDetector(3000);  
    vector<KeyPoint> keyPoint1, keyPoint2;
    surfDetector.detect(image1, keyPoint1);
    surfDetector.detect(image2, keyPoint2);

    //特徵點描述，為下邊的特徵點匹配做準備    
    OrbDescriptorExtractor  SurfDescriptor;
    Mat imageDesc1, imageDesc2;
    SurfDescriptor.compute(image1, keyPoint1, imageDesc1);
    SurfDescriptor.compute(image2, keyPoint2, imageDesc2);

    flann::Index flannIndex(imageDesc1, flann::LshIndexParams(12, 20, 2), cvflann::FLANN_DIST_HAMMING);

    vector<DMatch> GoodMatchePoints;

    Mat macthIndex(imageDesc2.rows, 2, CV_32SC1), matchDistance(imageDesc2.rows, 2, CV_32FC1);
    flannIndex.knnSearch(imageDesc2, macthIndex, matchDistance, 2, flann::SearchParams());

    // Lowe's algorithm,獲取優秀匹配點
    for (int i = 0; i < matchDistance.rows; i++)
    {
        if (matchDistance.at<float>(i, 0) < 0.4 * matchDistance.at<float>(i, 1))
        {
            DMatch dmatches(i, macthIndex.at<int>(i, 0), matchDistance.at<float>(i, 0));
            GoodMatchePoints.push_back(dmatches);
        }
    }

    Mat first_match;
    drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
    imshow("first_match ", first_match);

    vector<Point2f> imagePoints1, imagePoints2;

    for (int i = 0; i<GoodMatchePoints.size(); i++)
    {
        imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
        imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
    }



    //獲取影象1到影象2的投影對映矩陣 尺寸為3*3  
    Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
    ////也可以使用getPerspectiveTransform方法獲得透視變換矩陣，不過要求只能有4個點，效果稍差  
    //Mat   homo=getPerspectiveTransform(imagePoints1,imagePoints2);  
    cout << "變換矩陣為：\n" << homo << endl << endl; //輸出對映矩陣      

                                                //計算配準圖的四個頂點座標
    CalcCorners(homo, image01);
    cout << "left_top:" << corners.left_top << endl;
    cout << "left_bottom:" << corners.left_bottom << endl;
    cout << "right_top:" << corners.right_top << endl;
    cout << "right_bottom:" << corners.right_bottom << endl;

    //影象配準  
    Mat imageTransform1, imageTransform2;
    warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
    //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
    imshow("直接經過透視矩陣變換", imageTransform1);
    imwrite("trans1.jpg", imageTransform1);


    //建立拼接後的圖,需提前計算圖的大小
    int dst_width = imageTransform1.cols;  //取最右點的長度為拼接圖的長度
    int dst_height = image02.rows;

    Mat dst(dst_height, dst_width, CV_8UC3);
    dst.setTo(0);

    imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
    image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));

    imshow("b_dst", dst);


    OptimizeSeam(image02, imageTransform1, dst);


    imshow("dst", dst);
    imwrite("dst.jpg", dst);

    waitKey();

    return 0;
}


//優化兩圖的連線處，使得拼接自然
void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
{
    int start = MIN(corners.left_top.x, corners.left_bottom.x);//開始位置，即重疊區域的左邊界  

    double processWidth = img1.cols - start;//重疊區域的寬度  
    int rows = dst.rows;
    int cols = img1.cols; //注意，是列數*通道數
    double alpha = 1;//img1中畫素的權重  
    for (int i = 0; i < rows; i++)
    {
        uchar* p = img1.ptr<uchar>(i);  //獲取第i行的首地址
        uchar* t = trans.ptr<uchar>(i);
        uchar* d = dst.ptr<uchar>(i);
        for (int j = start; j < cols; j++)
        {
            //如果遇到影象trans中無畫素的黑點，則完全拷貝img1中的資料
            if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
            {
                alpha = 1;
            }
            else
            {
                //img1中畫素的權重，與當前處理點距重疊區域左邊界的距離成正比，實驗證明，這種方法確實好  
                alpha = (processWidth - (j - start)) / processWidth;
            }

            d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
            d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
            d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);

        }
    }

}

看一看拼接效果，我覺得還是不錯的。

1093303-20170822154629152-1101551803.png

1093303-20170822154650761-693802456.png

1093303-20170822154706636-1756490695.png

看一下這一組圖片，這組圖片產生了鬼影，為什麼？因為兩幅圖中的人物走動了啊！所以要做影象拼接，儘量保證使用的是靜態圖片，不要加入一些動態因素干擾拼接。

1093303-20170822154718027-805234486.png

1093303-20170822154727636-1873510992.png

1093303-20170822154736230-1197649063.png

opencv自帶的拼接演算法stitch

opencv其實自己就有實現影象拼接的演算法，當然效果也是相當好的，但是因為其實現很複雜，而且程式碼量很龐大，其實在一些小應用下的拼接有點殺雞用牛刀的感覺。最近在閱讀sticth原始碼時，發現其中有幾個很有意思的地方。

1.opencv stitch選擇的特徵檢測方式

一直很好奇opencv stitch演算法到底選用了哪個演算法作為其特徵檢測方式，是ORB，SIFT還是SURF？讀原始碼終於看到答案。

#ifdef HAVE_OPENCV_NONFREE
        stitcher.setFeaturesFinder(new detail::SurfFeaturesFinder());
#else
        stitcher.setFeaturesFinder(new detail::OrbFeaturesFinder());
#endif

在原始碼createDefault函式中（預設設定），第一選擇是SURF,第二選擇才是ORB（沒有NONFREE模組才選），所以既然大牛們這麼選擇，必然是經過綜合考慮的，所以應該SURF演算法在影象拼接有著更優秀的效果。

2.opencv stitch獲取匹配點的方式

以下程式碼是opencv stitch原始碼中的特徵點提取部分，作者使用了兩次特徵點提取的思路：先對圖一進行特徵點提取和篩選匹配（1->2），再對圖二進行特徵點的提取和匹配（2->1），這跟我們平時的一次提取的思路不同，這種二次提取的思路可以保證更多的匹配點被選中，匹配點越多，findHomography求出的變換越準確。這個思路值得借鑑。


matches_info.matches.clear();

Ptr<flann::IndexParams> indexParams = new flann::KDTreeIndexParams();
Ptr<flann::SearchParams> searchParams = new flann::SearchParams();

if (features2.descriptors.depth() == CV_8U)
{
    indexParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
    searchParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
}

FlannBasedMatcher matcher(indexParams, searchParams);
vector< vector<DMatch> > pair_matches;
MatchesSet matches;

// Find 1->2 matches
matcher.knnMatch(features1.descriptors, features2.descriptors, pair_matches, 2);
for (size_t i = 0; i < pair_matches.size(); ++i)
{
    if (pair_matches[i].size() < 2)
        continue;
    const DMatch& m0 = pair_matches[i][0];
    const DMatch& m1 = pair_matches[i][1];
    if (m0.distance < (1.f - match_conf_) * m1.distance)
    {
        matches_info.matches.push_back(m0);
        matches.insert(make_pair(m0.queryIdx, m0.trainIdx));
    }
}
LOG("\n1->2 matches: " << matches_info.matches.size() << endl);

// Find 2->1 matches
pair_matches.clear();
matcher.knnMatch(features2.descriptors, features1.descriptors, pair_matches, 2);
for (size_t i = 0; i < pair_matches.size(); ++i)
{
    if (pair_matches[i].size() < 2)
        continue;
    const DMatch& m0 = pair_matches[i][0];
    const DMatch& m1 = pair_matches[i][1];
    if (m0.distance < (1.f - match_conf_) * m1.distance)
        if (matches.find(make_pair(m0.trainIdx, m0.queryIdx)) == matches.end())
            matches_info.matches.push_back(DMatch(m0.trainIdx, m0.queryIdx, m0.distance));
}
LOG("1->2 & 2->1 matches: " << matches_info.matches.size() << endl);

這裡我仿照opencv原始碼二次提取特徵點的思路對我原有拼接程式碼進行改寫，實驗證明獲取的匹配點確實較一次提取要多。

//提取特徵點    
SiftFeatureDetector Detector(1000);  // 海塞矩陣閾值，在這裡調整精度，值越大點越少，越精準 
vector<KeyPoint> keyPoint1, keyPoint2;
Detector.detect(image1, keyPoint1);
Detector.detect(image2, keyPoint2);

//特徵點描述，為下邊的特徵點匹配做準備    
SiftDescriptorExtractor Descriptor;
Mat imageDesc1, imageDesc2;
Descriptor.compute(image1, keyPoint1, imageDesc1);
Descriptor.compute(image2, keyPoint2, imageDesc2);

FlannBasedMatcher matcher;
vector<vector<DMatch> > matchePoints;
vector<DMatch> GoodMatchePoints;

MatchesSet matches;

vector<Mat> train_desc(1, imageDesc1);
matcher.add(train_desc);
matcher.train();

matcher.knnMatch(imageDesc2, matchePoints, 2);

// Lowe's algorithm,獲取優秀匹配點
for (int i = 0; i < matchePoints.size(); i++)
{
    if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
    {
        GoodMatchePoints.push_back(matchePoints[i][0]);
        matches.insert(make_pair(matchePoints[i][0].queryIdx, matchePoints[i][0].trainIdx));
    }
}
cout<<"\n1->2 matches: " << GoodMatchePoints.size() << endl;

#if 1

FlannBasedMatcher matcher2;
matchePoints.clear();
vector<Mat> train_desc2(1, imageDesc2);
matcher2.add(train_desc2);
matcher2.train();

matcher2.knnMatch(imageDesc1, matchePoints, 2);
// Lowe's algorithm,獲取優秀匹配點
for (int i = 0; i < matchePoints.size(); i++)
{
    if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
    {
        if (matches.find(make_pair(matchePoints[i][0].trainIdx, matchePoints[i][0].queryIdx)) == matches.end())
        {
            GoodMatchePoints.push_back(DMatch(matchePoints[i][0].trainIdx, matchePoints[i][0].queryIdx, matchePoints[i][0].distance));
        }
        
    }
}
cout<<"1->2 & 2->1 matches: " << GoodMatchePoints.size() << endl;
#endif

最後再看一下opencv stitch的拼接效果吧~速度雖然比較慢，但是效果還是很好的。

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/stitching/stitcher.hpp>
using namespace std;
using namespace cv;
bool try_use_gpu = false;
vector<Mat> imgs;
string result_name = "dst1.jpg";
int main(int argc, char * argv[])
{
    Mat img1 = imread("34.jpg");
    Mat img2 = imread("35.jpg");

    imshow("p1", img1);
    imshow("p2", img2);

    if (img1.empty() || img2.empty())
    {
        cout << "Can't read image" << endl;
        return -1;
    }
    imgs.push_back(img1);
    imgs.push_back(img2);


    Stitcher stitcher = Stitcher::createDefault(try_use_gpu);
    // 使用stitch函式進行拼接
    Mat pano;
    Stitcher::Status status = stitcher.stitch(imgs, pano);
    if (status != Stitcher::OK)
    {
        cout << "Can't stitch images, error code = " << int(status) << endl;
        return -1;
    }
    imwrite(result_name, pano);
    Mat pano2 = pano.clone();
    // 顯示源影象，和結果影象
    imshow("全景影象", pano);
    if (waitKey() == 27)
        return 0;
}

1093303-20170822154805043-430469339.png

1093303-20170822154823308-950402280.png

相關推薦

OpenCV探索之路（二十四）影象拼接和影象融合技術

影象拼接在實際的應用場景很廣，比如無人機航拍，遙感影象等等，影象拼接是進一步做影象理解基礎步驟，拼接效果的好壞直接影響接下來的工作，所以一個好的影象拼接演算法非常重要。 再舉一個身邊的例子吧，你用你的手機對某一場景拍照，但是你沒有辦法一次將所有你要拍的景物全部拍下來，所以你

OpenCV探索之路（二十六）：如何去除票據上的印章

com 票據 uid amp 去除 album 探索 ace 十六 http://pic.cnhubei.com/space.php?uid=1774&do=album&id=1338281http://pic.cnhubei.com/space.php?u

Python小白學習之路（二十四）—【裝飾器】

裝飾器 一、裝飾器的本質 裝飾器的本質就是函式，功能就是為其他函式新增附加功能。 利用裝飾器給其他函式新增附加功能時的原則：         1.不能修改被修飾函式的原始碼        2.不能修改被修飾函式的呼叫方式

Java 從入門到進階之路（二十四）

在之前的文章我們介紹了一下 Java 中的  集合框架中的Collection 的泛型，本章我們來看一下 Java 集合框架中的Collection 的子介面 List。 Collection 介面有 3 種子型別，List、Set 和 Queue，其中 List 和 Set 的區別是 Set 中不

Spark學習之路 （二十八）分布式圖計算系統

尺度 內存 底層 mapr 分區 ces 兩個 傳遞方式 cat 一、引言 　　在了解GraphX之前，需要先了解關於通用的分布式圖計算框架的兩個常見問題：圖存儲模式和圖計算模式。 二、圖存儲模式 　　巨型圖的存儲總體上有邊分割和點分割兩種存儲方式。2013年，Gra

Python小白學習之路（二十一）—【迭代器】

迭代器 1.迭代器協議 物件必須提供一個 next 方法，執行該方法要麼返回迭代中的下一項，要麼就引起一個Stoplteration異常，以終止迭代（只能往後走不能往前退） 2.可迭代物件 實現了迭代器協議的物件（如何實現：物件內部定義一個_iter_()方法） 協議是一種約定，可迭代物件實現了

unity官方demo學習之Stealth（二十四）敵人AI

1，新增指令碼檔案DoneEnemyAI using UnityEngine; using System.Collections; public class DoneEnemyAI : MonoBehaviour { public float patrolSpeed

全棧JavaScript之路（ 二十一）HTML5 scrollIntoView方法

HTML5中，scrollIntoView()可以在所有HTML 元素上呼叫 通過滾動瀏覽器視窗或某個容器元素，呼叫元素就可以出現在視口中。 如果給這個方法傳入true 作為引數，或者不傳入任何引數，那麼視窗滾動之後會讓呼叫元素的頂部與視窗頂部儘可能平齊。 如果傳入fa

Java 從入門到進階之路（二十一）

在之前的文章我們介紹了一下 Java 中的日期操作，本章我們來看一下 Java 集合框架中的Collection。 早在 Java 2 中之前，Java 就提供了特設類。比如：Dictionary, Vector, Stack, 和 Properties 這些類用來儲存和操作物件組。 雖然這些類都非常有用，但

Java 從入門到進階之路（二十五）

在之前的文章我們介紹了一下 Java 中的  集合框架中的Collection 的子介面 List的 增刪改查和與陣列間相互轉換的方法，本章我們來看一下 Java 集合框架中的Collection 的子介面 List 的另外一些方法。 我們在使用集合的時候難免會對其中的元素進行排序，因為 Set 集

Java 從入門到進階之路（二十六）

在之前的文章我們介紹了一下 Java 中的  集合框架中的Collection 的子介面 List，本章我們來看一下 Java 集合框架中的Collection 的子介面 Queue。 在之前我們講 List 和 Set 的時候可以通過下標的形式獲取想要的元素，在 Collection 中其實還有

Java 從入門到進階之路（二十八）

在之前的文章我們都是通過 Java 在記憶體中應用，本章開始我們來看一下 Java 在系統檔案（硬碟）上的操作。 系統檔案就是我們電腦中的檔案，簡單來說就是像 Windows 系統中 C D E 等各類碟符中的檔案。Java 在系統檔案的操作需要通過  File 來完成。 接下來我們通過一個簡單的例

Java 從入門到進階之路（二十九）

在之前的文章我們已經可以對本地對檔案和目錄進行新建和刪除等操作，接下來我們來對檔案內對具體內容進行操作。 如下程式碼，我們實現了一個基本的檔案寫入： 1 /** 2 * java.io.RandomAccessFile 3 * 用來讀寫檔案資料 4 * RAF是基於指標進行讀寫的，即RAF總是

Linux學習筆記（二十四）管道符和作業控制、shell變量、環境變量配置文件

環境變量配置文件 管道符 一、管道符和作業控制cat 1.txt |wc -l ; cat 1.txt |grep ‘aaa‘將前面命令的結果輸入給後面的命令ctrl z 暫停一個任務、這時候任務隱藏到後臺，通過fg可以重新吊起任務到前臺運行jobs查看後臺的任務bg[id]把任務調到後臺fg[id]

OpenCV探索之路（十六）：圖像矯正技術深入探討

double gb2 教科書 長方形 strong fine open lines 導致 剛進入實驗室導師就交給我一個任務，就是讓我設計算法給圖像進行矯正。哎呀，我不太會圖像這塊啊，不過還是接下來了，硬著頭皮開幹吧！ 那什麽是圖像的矯正呢？舉個例子就好明白了。 我的好朋友小

OpenCV探索之路（十五）：角點檢測

回調函數 閾值 source and 類型 幾何 擁有 .com named 角點檢測是計算機視覺系統中用來獲取圖像特征的一種方法。我們都常說，這幅圖像很有特點，但是一問他到底有哪些特點，或者這幅圖有哪些特征可以讓你一下子就識別出該物體，你可能就說不出來了。其實說圖像的特征

OpenCV探索之路（十八）：使用imwrite調整儲存的圖片質量

近日在用opencv做一些影象處理的操作時，需要對一些高解析度的影象進行儲存。比如，在操作一個容量為230M的影象後，並對該影象儲存為JPG格式後，發現影象容量變為80M了！針對這個問題，忙了大半天，到處翻閱資料，終於知道為什麼了。 先舉個例子說明自己遇到的問題，為了看出效果，我特意用了一個高解析度的圖片做實

OpenCV探索之路（十三）：詳解掩膜mask

ret 如果 拷貝 ace 設置 之路 動作 與運算 區域 在OpenCV中我們經常會遇到一個名字:Mask(掩膜)。很多函數都使用到它，那麽這個Mask到底什麽呢？ 一開始我接觸到Mask這個東西時，我還真是一頭霧水啊，也對無法理解Mask到底有什麽用。經過查閱大量資料後

全棧JavaScript之路（ 二十 ）HTML5 插入 html標記 （ 二 ）insertAdjacentHTML

ava html ace erb class 之前 一個 chrom asc insertAdjacentHTML(), 這種方法也是在IE中最早出現的。如今已納入html5規範，它接受兩個參數，一個是下列的標記之中的一個，一個是要寫入的 html 代碼文本。

Python學習（二十四）—— 前端基礎之Bookstrap

asc script nta 學習 基本 www. red hicon 分享 一、Bootstrap介紹 Bootstrap是Twitter開源的基於HTML、CSS、JavaScript的前端框架。 它是為實現快速開發Web應用程序而設計的一套前端工具包。 它支持響應式布