完整拼接代碼 - opencv的圖像分割與融合技術(shù)

　　最后給出完整的SURF算法實(shí)現(xiàn)的拼接代碼。

　　#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］;//變換后的坐標(biāo)值

　　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）;

　　//灰度圖轉(zhuǎn)換

　　Mat image1， image2;

　　cvtColor（image01， image1， CV_RGB2GRAY）;

　　cvtColor（image02， image2， CV_RGB2GRAY）;

　　//提取特征點(diǎn)

　　SurfFeatureDetector Detector（2000）;

　　vector《KeyPoint》 keyPoint1， keyPoint2;

　　Detector.detect（image1， keyPoint1）;

　　Detector.detect（image2， keyPoint2）;

　　//特征點(diǎn)描述，為下邊的特征點(diǎn)匹配做準(zhǔn)備

　　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，獲取優(yōu)秀匹配點(diǎn)

　　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個點(diǎn)，效果稍差

　　//Mat homo=getPerspectiveTransform（imagePoints1，imagePoints2）;

　　cout 《《 “變換矩陣為： ” 《《 homo 《《 endl 《《 endl; //輸出映射矩陣

　　//計(jì)算配準(zhǔn)圖的四個頂點(diǎn)坐標(biāo)

　　CalcCorners（homo， image01）;

　　cout 《《 “l(fā)eft_top：” 《《 corners.left_top 《《 endl;

　　cout 《《 “l(fā)eft_bottom：” 《《 corners.left_bottom 《《 endl;

　　cout 《《 “right_top：” 《《 corners.right_top 《《 endl;

　　cout 《《 “right_bottom：” 《《 corners.right_bottom 《《 endl;

　　//圖像配準(zhǔn)

　　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（“直接經(jīng)過透視矩陣變換”， imageTransform1）;

　　imwrite（“trans1.jpg”， imageTransform1）;

　　//創(chuàng)建拼接后的圖，需提前計(jì)算圖的大小

　　int dst_width = imageTransform1.cols; //取最右點(diǎn)的長度為拼接圖的長度

　　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;

　　}

　　//優(yōu)化兩圖的連接處，使得拼接自然

　　void OptimizeSeam（Mat& img1， Mat& trans， Mat& dst）

　　{

　　int start = MIN（corners.left_top.x， corners.left_bottom.x）;//開始位置，即重疊區(qū)域的左邊界

　　double processWidth = img1.cols - start;//重疊區(qū)域的寬度

　　int rows = dst.rows;

　　int cols = img1.cols; //注意，是列數(shù)*通道數(shù)

　　double alpha = 1;//img1中像素的權(quán)重

　　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中無像素的黑點(diǎn)，則完全拷貝img1中的數(shù)據(jù)

　　if （t［j * 3］ == 0 && t［j * 3 + 1］ == 0 && t［j * 3 + 2］ == 0）

　　{

　　alpha = 1;

　　}

　　else

　　{

　　//img1中像素的權(quán)重，與當(dāng)前處理點(diǎn)距重疊區(qū)域左邊界的距離成正比，實(shí)驗(yàn)證明，這種方法確實(shí)好

　　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）;

　　}

　　}

　　}

　　}