OpenCV 影象拼接和影象融合技術
阿新 • • 發佈：2020-12-23
影象拼接在實際的應用場景很廣，比如無人機航拍，遙感影象等等，影象拼接是進一步做影象理解基礎步驟，拼接效果的好壞直接影響接下來的工作，所以一個好的影象拼接演算法非常重要。
再舉一個身邊的例子吧，你用你的手機對某一場景拍照，但是你沒有辦法一次將所有你要拍的景物全部拍下來，所以你對該場景從左往右依次拍了好幾張圖，來把你要拍的所有景物記錄下來。那麼我們能不能把這些影象拼接成一個大圖呢？我們利用opencv就可以做到影象拼接的效果！
比如我們有對這兩張圖進行拼接。
從上面兩張圖可以看出，這兩張圖有比較多的重疊部分，這也是拼接的基本要求。
那麼要實現影象拼接需要那幾步呢？簡單來說有以下幾步：
- 對每幅圖進行特徵點提取
- 對對特徵點進行匹配
- 進行影象配準
- 把影象拷貝到另一幅影象的特定位置
- 對重疊邊界進行特殊處理
好吧，那就開始正式實現影象配準。
第一步就是特徵點提取。現在CV領域有很多特徵點的定義，比如sift、surf、harris角點、ORB都是很有名的特徵因子，都可以用來做影象拼接的工作，他們各有優勢。本文將使用ORB和SURF進行影象拼接，用其他方法進行拼接也是類似的。
基於SURF的影象拼接
用SIFT演算法來實現影象拼接是很常用的方法，但是因為SIFT計算量很大，所以在速度要求很高的場合下不再適用。所以，它的改進方法SURF因為在速度方面有了明顯的提高（速度是SIFT的3倍），所以在影象拼接領域還是大有作為。雖說SURF精確度和穩定性不及SIFT，但是其綜合能力還是優越一些。下面將詳細介紹拼接的主要步驟。
1.特徵點提取和匹配
1 //提取特徵點
2 SurfFeatureDetector Detector(2000);
3 vector<KeyPoint> keyPoint1, keyPoint2;
4 Detector.detect(image1, keyPoint1);
5 Detector.detect(image2, keyPoint2);
6
7 //特徵點描述，為下邊的特徵點匹配做準備
8 SurfDescriptorExtractor Descriptor;
9 Mat imageDesc1, imageDesc2;
10 Descriptor.compute(image1, keyPoint1, imageDesc1);
2.影象配準
這樣子我們就可以得到了兩幅待拼接圖的匹配點集，接下來我們進行影象的配準，即將兩張影象轉換為同一座標下，這裡我們需要使用findHomography函式來求得變換矩陣。但是需要注意的是，findHomography函式所要用到的點集是Point2f型別的，所有我們需要對我們剛得到的點集GoodMatchePoints再做一次處理，使其轉換為Point2f型別的點集。
1 vector<Point2f> imagePoints1, imagePoints2;
2
3 for (int i = 0; i<GoodMatchePoints.size(); i++)
4 {
5 imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
6 imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
7 }
這樣子，我們就可以拿著imagePoints1, imagePoints2去求變換矩陣了，並且實現影象配準。值得注意的是findHomography函式的引數中我們選澤了CV_RANSAC，這表明我們選擇RANSAC演算法繼續篩選可靠地匹配點，這使得匹配點解更為精確。
1 //獲取影象1到影象2的投影對映矩陣 尺寸為3*3
2 Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
3 ////也可以使用getPerspectiveTransform方法獲得透視變換矩陣，不過要求只能有4個點，效果稍差
4 //Mat homo=getPerspectiveTransform(imagePoints1,imagePoints2);
5 cout << "變換矩陣為：\n" << homo << endl << endl; //輸出對映矩陣
6
7 //影象配準
8 Mat imageTransform1, imageTransform2;
9 warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
10 //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
11 imshow("直接經過透視矩陣變換", imageTransform1);
12 imwrite("trans1.jpg", imageTransform1);
3. 影象拷貝
拷貝的思路很簡單，就是將左圖直接拷貝到配準圖上就可以了。
1 //建立拼接後的圖,需提前計算圖的大小
2 int dst_width = imageTransform1.cols; //取最右點的長度為拼接圖的長度
3 int dst_height = image02.rows;
4
5 Mat dst(dst_height, dst_width, CV_8UC3);
6 dst.setTo(0);
7
8 imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
9 image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));
10
11 imshow("b_dst", dst);
4.影象融合（去裂縫處理）
從上圖可以看出，兩圖的拼接並不自然，原因就在於拼接圖的交界處，兩圖因為光照色澤的原因使得兩圖交界處的過渡很糟糕，所以需要特定的處理解決這種不自然。這裡的處理思路是加權融合，在重疊部分由前一幅影象慢慢過渡到第二幅影象，即將影象的重疊區域的畫素值按一定的權值相加合成新的影象。
1 //優化兩圖的連線處，使得拼接自然
2 void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
3 {
4 int start = MIN(corners.left_top.x, corners.left_bottom.x);//開始位置，即重疊區域的左邊界
5
6 double processWidth = img1.cols - start;//重疊區域的寬度
7 int rows = dst.rows;
8 int cols = img1.cols; //注意，是列數*通道數
9 double alpha = 1;//img1中畫素的權重
10 for (int i = 0; i < rows; i++)
11 {
12 uchar* p = img1.ptr<uchar>(i); //獲取第i行的首地址
13 uchar* t = trans.ptr<uchar>(i);
14 uchar* d = dst.ptr<uchar>(i);
15 for (int j = start; j < cols; j++)
16 {
17 //如果遇到影象trans中無畫素的黑點，則完全拷貝img1中的資料
18 if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
19 {
20 alpha = 1;
21 }
22 else
23 {
24 //img1中畫素的權重，與當前處理點距重疊區域左邊界的距離成正比，實驗證明，這種方法確實好
25 alpha = (processWidth - (j - start)) / processWidth;
26 }
27
28 d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
29 d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
30 d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);
31
32 }
33 }
34 }
多嘗試幾張，驗證拼接效果
測試一
測試二
測試三
最後給出完整的SURF演算法實現的拼接程式碼。
1 #include "highgui/highgui.hpp"
2 #include "opencv2/nonfree/nonfree.hpp"
3 #include "opencv2/legacy/legacy.hpp"
4 #include <iostream>
5
6 using namespace cv;
7 using namespace std;
8
9 void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);
10
11 typedef struct
12 {
13 Point2f left_top;
14 Point2f left_bottom;
15 Point2f right_top;
16 Point2f right_bottom;
17 }four_corners_t;
18
19 four_corners_t corners;
20
21 void CalcCorners(const Mat& H, const Mat& src)
22 {
23 double v2[] = { 0, 0, 1 };//左上角
24 double v1[3];//變換後的座標值
25 Mat V2 = Mat(3, 1, CV_64FC1, v2); //列向量
26 Mat V1 = Mat(3, 1, CV_64FC1, v1); //列向量
27
28 V1 = H * V2;
29 //左上角(0,0,1)
30 cout << "V2: " << V2 << endl;
31 cout << "V1: " << V1 << endl;
32 corners.left_top.x = v1[0] / v1[2];
33 corners.left_top.y = v1[1] / v1[2];
34
35 //左下角(0,src.rows,1)
36 v2[0] = 0;
37 v2[1] = src.rows;
38 v2[2] = 1;
39 V2 = Mat(3, 1, CV_64FC1, v2); //列向量
40 V1 = Mat(3, 1, CV_64FC1, v1); //列向量
41 V1 = H * V2;
42 corners.left_bottom.x = v1[0] / v1[2];
43 corners.left_bottom.y = v1[1] / v1[2];
44
45 //右上角(src.cols,0,1)
46 v2[0] = src.cols;
47 v2[1] = 0;
48 v2[2] = 1;
49 V2 = Mat(3, 1, CV_64FC1, v2); //列向量
50 V1 = Mat(3, 1, CV_64FC1, v1); //列向量
51 V1 = H * V2;
52 corners.right_top.x = v1[0] / v1[2];
53 corners.right_top.y = v1[1] / v1[2];
54
55 //右下角(src.cols,src.rows,1)
56 v2[0] = src.cols;
57 v2[1] = src.rows;
58 v2[2] = 1;
59 V2 = Mat(3, 1, CV_64FC1, v2); //列向量
60 V1 = Mat(3, 1, CV_64FC1, v1); //列向量
61 V1 = H * V2;
62 corners.right_bottom.x = v1[0] / v1[2];
63 corners.right_bottom.y = v1[1] / v1[2];
64
65 }
66
67 int main(int argc, char *argv[])
68 {
69 Mat image01 = imread("g5.jpg", 1); //右圖
70 Mat image02 = imread("g4.jpg", 1); //左圖
71 imshow("p2", image01);
72 imshow("p1", image02);
73
74 //灰度圖轉換
75 Mat image1, image2;
76 cvtColor(image01, image1, CV_RGB2GRAY);
77 cvtColor(image02, image2, CV_RGB2GRAY);
78
79
80 //提取特徵點
81 SurfFeatureDetector Detector(2000);
82 vector<KeyPoint> keyPoint1, keyPoint2;
83 Detector.detect(image1, keyPoint1);
84 Detector.detect(image2, keyPoint2);
85
86 //特徵點描述，為下邊的特徵點匹配做準備
87 SurfDescriptorExtractor Descriptor;
88 Mat imageDesc1, imageDesc2;
89 Descriptor.compute(image1, keyPoint1, imageDesc1);
90 Descriptor.compute(image2, keyPoint2, imageDesc2);
91
92 FlannBasedMatcher matcher;
93 vector<vector<DMatch> > matchePoints;
94 vector<DMatch> GoodMatchePoints;
95
96 vector<Mat> train_desc(1, imageDesc1);
97 matcher.add(train_desc);
98 matcher.train();
99
100 matcher.knnMatch(imageDesc2, matchePoints, 2);
101 cout << "total match points: " << matchePoints.size() << endl;
102
103 // Lowe's algorithm,獲取優秀匹配點
104 for (int i = 0; i < matchePoints.size(); i++)
105 {
106 if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
107 {
108 GoodMatchePoints.push_back(matchePoints[i][0]);
109 }
110 }
111
112 Mat first_match;
113 drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
114 imshow("first_match ", first_match);
115
116 vector<Point2f> imagePoints1, imagePoints2;
117
118 for (int i = 0; i<GoodMatchePoints.size(); i++)
119 {
120 imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
121 imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
122 }
123
124
125
126 //獲取影象1到影象2的投影對映矩陣 尺寸為3*3
127 Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
128 ////也可以使用getPerspectiveTransform方法獲得透視變換矩陣，不過要求只能有4個點，效果稍差
129 //Mat homo=getPerspectiveTransform(imagePoints1,imagePoints2);
130 cout << "變換矩陣為：\n" << homo << endl << endl; //輸出對映矩陣
131
132 //計算配準圖的四個頂點座標
133 CalcCorners(homo, image01);
134 cout << "left_top:" << corners.left_top << endl;
135 cout << "left_bottom:" << corners.left_bottom << endl;
136 cout << "right_top:" << corners.right_top << endl;
137 cout << "right_bottom:" << corners.right_bottom << endl;
138
139 //影象配準
140 Mat imageTransform1, imageTransform2;
141 warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
142 //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
143 imshow("直接經過透視矩陣變換", imageTransform1);
144 imwrite("trans1.jpg", imageTransform1);
145
146
147 //建立拼接後的圖,需提前計算圖的大小
148 int dst_width = imageTransform1.cols; //取最右點的長度為拼接圖的長度
149 int dst_height = image02.rows;
150
151 Mat dst(dst_height, dst_width, CV_8UC3);
152 dst.setTo(0);
153
154 imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
155 image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));
156
157 imshow("b_dst", dst);
158
159
160 OptimizeSeam(image02, imageTransform1, dst);
161
162
163 imshow("dst", dst);
164 imwrite("dst.jpg", dst);
165
166 waitKey();
167
168 return 0;
169 }
170
171
172 //優化兩圖的連線處，使得拼接自然
173 void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
174 {
175 int start = MIN(corners.left_top.x, corners.left_bottom.x);//開始位置，即重疊區域的左邊界
176
177 double processWidth = img1.cols - start;//重疊區域的寬度
178 int rows = dst.rows;
179 int cols = img1.cols; //注意，是列數*通道數
180 double alpha = 1;//img1中畫素的權重
181 for (int i = 0; i < rows; i++)
182 {
183 uchar* p = img1.ptr<uchar>(i); //獲取第i行的首地址
184 uchar* t = trans.ptr<uchar>(i);
185 uchar* d = dst.ptr<uchar>(i);
186 for (int j = start; j < cols; j++)
187 {
188 //如果遇到影象trans中無畫素的黑點，則完全拷貝img1中的資料
189 if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
190 {
191 alpha = 1;
192 }
193 else
194 {
195 //img1中畫素的權重，與當前處理點距重疊區域左邊界的距離成正比，實驗證明，這種方法確實好
196 alpha = (processWidth - (j - start)) / processWidth;
197 }
198
199 d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
200 d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
201 d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);
202
203 }
204 }
205 }
基於ORB的影象拼接
利用ORB進行影象拼接的思路跟上面的思路基本一樣，只是特徵提取和特徵點匹配的方式略有差異罷了。這裡就不再詳細介紹思路了，直接貼程式碼看效果。
1 #include "highgui/highgui.hpp"
2 #include "opencv2/nonfree/nonfree.hpp"
3 #include "opencv2/legacy/legacy.hpp"
4 #include <iostream>
5
6 using namespace cv;
7 using namespace std;
8
9 void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);
10
11 typedef struct
12 {
13 Point2f left_top;
14 Point2f left_bottom;
15 Point2f right_top;
16 Point2f right_bottom;
17 }four_corners_t;
18
19 four_corners_t corners;
20
21 void CalcCorners(const Mat& H, const Mat& src)
22 {
23 double v2[] = { 0, 0, 1 };//左上角
24 double v1[3];//變換後的座標值
25 Mat V2 = Mat(3, 1, CV_64FC1, v2); //列向量
26 Mat V1 = Mat(3, 1, CV_64FC1, v1); //列向量
27
28 V1 = H * V2;
29 //左上角(0,0,1)
30 cout << "V2: " << V2 << endl;
31 cout << "V1: " << V1 << endl;
32 corners.left_top.x = v1[0] / v1[2];
33 corners.left_top.y = v1[1] / v1[2];
34
35 //左下角(0,src.rows,1)
36 v2[0] = 0;
37 v2[1] = src.rows;
38 v2[2] = 1;
39 V2 = Mat(3, 1, CV_64FC1, v2); //列向量
40 V1 = Mat(3, 1, CV_64FC1, v1); //列向量
41 V1 = H * V2;
42 corners.left_bottom.x = v1[0] / v1[2];
43 corners.left_bottom.y = v1[1] / v1[2];
44
45 //右上角(src.cols,0,1)
46 v2[0] = src.cols;
47 v2[1] = 0;
48 v2[2] = 1;
49 V2 = Mat(3, 1, CV_64FC1, v2); //列向量
50 V1 = Mat(3, 1, CV_64FC1, v1); //列向量
51 V1 = H * V2;
52 corners.right_top.x = v1[0] / v1[2];
53 corners.right_top.y = v1[1] / v1[2];
54
55 //右下角(src.cols,src.rows,1)
56 v2[0] = src.cols;
57 v2[1] = src.rows;
58 v2[2] = 1;
59 V2 = Mat(3, 1, CV_64FC1, v2); //列向量
60 V1 = Mat(3, 1, CV_64FC1, v1); //列向量
61 V1 = H * V2;
62 corners.right_bottom.x = v1[0] / v1[2];
63 corners.right_bottom.y = v1[1] / v1[2];
64
65 }
66
67 int main(int argc, char *argv[])
68 {
69 Mat image01 = imread("t1.jpg", 1); //右圖
70 Mat image02 = imread("t2.jpg", 1); //左圖
71 imshow("p2", image01);
72 imshow("p1", image02);
73
74 //灰度圖轉換
75 Mat image1, image2;
76 cvtColor(image01, image1, CV_RGB2GRAY);
77 cvtColor(image02, image2, CV_RGB2GRAY);
78
79
80 //提取特徵點
81 OrbFeatureDetector surfDetector(3000);
82 vector<KeyPoint> keyPoint1, keyPoint2;
83 surfDetector.detect(image1, keyPoint1);
84 surfDetector.detect(image2, keyPoint2);
85
86 //特徵點描述，為下邊的特徵點匹配做準備
87 OrbDescriptorExtractor SurfDescriptor;
88 Mat imageDesc1, imageDesc2;
89 SurfDescriptor.compute(image1, keyPoint1, imageDesc1);
90 SurfDescriptor.compute(image2, keyPoint2, imageDesc2);
91
92 flann::Index flannIndex(imageDesc1, flann::LshIndexParams(12, 20, 2), cvflann::FLANN_DIST_HAMMING);
93
94 vector<DMatch> GoodMatchePoints;
95
96 Mat macthIndex(imageDesc2.rows, 2, CV_32SC1), matchDistance(imageDesc2.rows, 2, CV_32FC1);
97 flannIndex.knnSearch(imageDesc2, macthIndex, matchDistance, 2, flann::SearchParams());
98
99 // Lowe's algorithm,獲取優秀匹配點
100 for (int i = 0; i < matchDistance.rows; i++)
101 {
102 if (matchDistance.at<float>(i, 0) < 0.4 * matchDistance.at<float>(i, 1))
103 {
104 DMatch dmatches(i, macthIndex.at<int>(i, 0), matchDistance.at<float>(i, 0));
105 GoodMatchePoints.push_back(dmatches);
106 }
107 }
108
109 Mat first_match;
110 drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
111 imshow("first_match ", first_match);
112
113 vector<Point2f> imagePoints1, imagePoints2;
114
115 for (int i = 0; i<GoodMatchePoints.size(); i++)
116 {
117 imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
118 imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
119 }
120
121
122
123 //獲取影象1到影象2的投影對映矩陣 尺寸為3*3
124 Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
125 ////也可以使用getPerspectiveTransform方法獲得透視變換矩陣，不過要求只能有4個點，效果稍差
126 //Mat homo=getPerspectiveTransform(imagePoints1,imagePoints2);
127 cout << "變換矩陣為：\n" << homo << endl << endl; //輸出對映矩陣
128
129 //計算配準圖的四個頂點座標
130 CalcCorners(homo, image01);
131 cout << "left_top:" << corners.left_top << endl;
132 cout << "left_bottom:" << corners.left_bottom << endl;
133 cout << "right_top:" << corners.right_top << endl;
134 cout << "right_bottom:" << corners.right_bottom << endl;
135
136 //影象配準
137 Mat imageTransform1, imageTransform2;
138 warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
139 //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
140 imshow("直接經過透視矩陣變換", imageTransform1);
141 imwrite("trans1.jpg", imageTransform1);
142
143
144 //建立拼接後的圖,需提前計算圖的大小
145 int dst_width = imageTransform1.cols; //取最右點的長度為拼接圖的長度
146 int dst_height = image02.rows;
147
148 Mat dst(dst_height, dst_width, CV_8UC3);
149 dst.setTo(0);
150
151 imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
152 image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));
153
154 imshow("b_dst", dst);
155
156
157 OptimizeSeam(image02, imageTransform1, dst);
158
159
160 imshow("dst", dst);
161 imwrite("dst.jpg", dst);
162
163 waitKey();
164
165 return 0;
166 }
167
168
169 //優化兩圖的連線處，使得拼接自然
170 void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
171 {
172 int start = MIN(corners.left_top.x, corners.left_bottom.x);//開始位置，即重疊區域的左邊界
173
174 double processWidth = img1.cols - start;//重疊區域的寬度
175 int rows = dst.rows;
176 int cols = img1.cols; //注意，是列數*通道數
177 double alpha = 1;//img1中畫素的權重
178 for (int i = 0; i < rows; i++)
179 {
180 uchar* p = img1.ptr<uchar>(i); //獲取第i行的首地址
181 uchar* t = trans.ptr<uchar>(i);
182 uchar* d = dst.ptr<uchar>(i);
183 for (int j = start; j < cols; j++)
184 {
185 //如果遇到影象trans中無畫素的黑點，則完全拷貝img1中的資料
186 if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
187 {
188 alpha = 1;
189 }
190 else
191 {
192 //img1中畫素的權重，與當前處理點距重疊區域左邊界的距離成正比，實驗證明，這種方法確實好
193 alpha = (processWidth - (j - start)) / processWidth;
194 }
195
196 d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
197 d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
198 d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);
199
200 }
201 }
202 }
看一看拼接效果，我覺得還是不錯的。
看一下這一組圖片，這組圖片產生了鬼影，為什麼？因為兩幅圖中的人物走動了啊！所以要做影象拼接，儘量保證使用的是靜態圖片，不要加入一些動態因素干擾拼接。
opencv自帶的拼接演算法stitch
opencv其實自己就有實現影象拼接的演算法，當然效果也是相當好的，但是因為其實現很複雜，而且程式碼量很龐大，其實在一些小應用下的拼接有點殺雞用牛刀的感覺。最近在閱讀sticth原始碼時，發現其中有幾個很有意思的地方。
1.opencv stitch選擇的特徵檢測方式
一直很好奇opencv stitch演算法到底選用了哪個演算法作為其特徵檢測方式，是ORB，SIFT還是SURF？讀原始碼終於看到答案。
1 #ifdef HAVE_OPENCV_NONFREE
2 stitcher.setFeaturesFinder(new detail::SurfFeaturesFinder());
3 #else
4 stitcher.setFeaturesFinder(new detail::OrbFeaturesFinder());
5 #endif
在原始碼createDefault函式中（預設設定），第一選擇是SURF,第二選擇才是ORB（沒有NONFREE模組才選），所以既然大牛們這麼選擇，必然是經過綜合考慮的，所以應該SURF演算法在影象拼接有著更優秀的效果。
2.opencv stitch獲取匹配點的方式
以下程式碼是opencv stitch原始碼中的特徵點提取部分，作者使用了兩次特徵點提取的思路：先對圖一進行特徵點提取和篩選匹配（1->2），再對圖二進行特徵點的提取和匹配（2->1），這跟我們平時的一次提取的思路不同，這種二次提取的思路可以保證更多的匹配點被選中，匹配點越多，findHomography求出的變換越準確。這個思路值得借鑑。
1 matches_info.matches.clear();
2
3 Ptr<flann::IndexParams> indexParams = new flann::KDTreeIndexParams();
4 Ptr<flann::SearchParams> searchParams = new flann::SearchParams();
5
6 if (features2.descriptors.depth() == CV_8U)
7 {
8 indexParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
9 searchParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
10 }
11
12 FlannBasedMatcher matcher(indexParams, searchParams);
13 vector< vector<DMatch> > pair_matches;
14 MatchesSet matches;
15
16 // Find 1->2 matches
17 matcher.knnMatch(features1.descriptors, features2.descriptors, pair_matches, 2);
18 for (size_t i = 0; i < pair_matches.size(); ++i)
19 {
20 if (pair_matches[i].size() < 2)
21 continue;
22 const DMatch& m0 = pair_matches[i][0];
23 const DMatch& m1 = pair_matches[i][1];
24 if (m0.distance < (1.f - match_conf_) * m1.distance)
25 {
26 matches_info.matches.push_back(m0);
27 matches.insert(make_pair(m0.queryIdx, m0.trainIdx));
28 }
29 }
30 LOG("\n1->2 matches: " << matches_info.matches.size() << endl);
31
32 // Find 2->1 matches
33 pair_matches.clear();
34 matcher.knnMatch(features2.descriptors, features1.descriptors, pair_matches, 2);
35 for (size_t i = 0; i < pair_matches.size(); ++i)
36 {
37 if (pair_matches[i].size() < 2)
38 continue;
39 const DMatch& m0 = pair_matches[i][0];
40 const DMatch& m1 = pair_matches[i][1];
41 if (m0.distance < (1.f - match_conf_) * m1.distance)
42 if (matches.find(make_pair(m0.trainIdx, m0.queryIdx)) == matches.end())
43 matches_info.matches.push_back(DMatch(m0.trainIdx, m0.queryIdx, m0.distance));
44 }
45 LOG("1->2 & 2->1 matches: " << matches_info.matches.size() << endl);
這裡我仿照opencv原始碼二次提取特徵點的思路對我原有拼接程式碼進行改寫，實驗證明獲取的匹配點確實較一次提取要多。
1 //提取特徵點
2 SiftFeatureDetector Detector(1000); // 海塞矩陣閾值，在這裡調整精度，值越大點越少，越精準
3 vector<KeyPoint> keyPoint1, keyPoint2;
4 Detector.detect(image1, keyPoint1);
5 Detector.detect(image2, keyPoint2);
6
7 //特徵點描述，為下邊的特徵點匹配做準備
8 SiftDescriptorExtractor Descriptor;
9 Mat imageDesc1, imageDesc2;
10 Descriptor.compute(image1, keyPoint1, imageDesc1);
11 Descriptor.compute(image2, keyPoint2, imageDesc2);
12
13 FlannBasedMatcher matcher;
14 vector<vector<DMatch> > matchePoints;
15 vector<DMatch> GoodMatchePoints;
16
17 MatchesSet matches;
18
19 vector<Mat> train_desc(1, imageDesc1);
20 matcher.add(train_desc);
21 matcher.train();
22
23 matcher.knnMatch(imageDesc2, matchePoints, 2);
24
25 // Lowe's algorithm,獲取優秀匹配點
26 for (int i = 0; i < matchePoints.size(); i++)
27 {
28 if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
29 {
30 GoodMatchePoints.push_back(matchePoints[i][0]);
31 matches.insert(make_pair(matchePoints[i][0].queryIdx, matchePoints[i][0].trainIdx));
32 }
33 }
34 cout<<"\n1->2 matches: " << GoodMatchePoints.size() << endl;
35
36 #if 1
37
38 FlannBasedMatcher matcher2;
39 matchePoints.clear();
40 vector<Mat> train_desc2(1, imageDesc2);
41 matcher2.add(train_desc2);
42 matcher2.train();
43
44 matcher2.knnMatch(imageDesc1, matchePoints, 2);
45 // Lowe's algorithm,獲取優秀匹配點
46 for (int i = 0; i < matchePoints.size(); i++)
47 {
48 if (matchePoints[i][0].distance < 0.4 * matchePoints[i][1].distance)
49 {
50 if (matches.find(make_pair(matchePoints[i][0].trainIdx, matchePoints[i][0].queryIdx)) == matches.end())
51 {
52 GoodMatchePoints.push_back(DMatch(matchePoints[i][0].trainIdx, matchePoints[i][0].queryIdx, matchePoints[i][0].distance));
53 }
54
55 }
56 }
57 cout<<"1->2 & 2->1 matches: " << GoodMatchePoints.size() << endl;
58 #endif
最後再看一下opencv stitch的拼接效果吧~速度雖然比較慢，但是效果還是很好的。
1 #include <iostream>
2 #include <opencv2/core/core.hpp>
3 #include <opencv2/highgui/highgui.hpp>
4 #include <opencv2/imgproc/imgproc.hpp>
5 #include <opencv2/stitching/stitcher.hpp>
6 using namespace std;
7 using namespace cv;
8 bool try_use_gpu = false;
9 vector<Mat> imgs;
10 string result_name = "dst1.jpg";
11 int main(int argc, char * argv[])
12 {
13 Mat img1 = imread("34.jpg");
14 Mat img2 = imread("35.jpg");
15
16 imshow("p1", img1);
17 imshow("p2", img2);
18
19 if (img1.empty() || img2.empty())
20 {
21 cout << "Can't read image" << endl;
22 return -1;
23 }
24 imgs.push_back(img1);
25 imgs.push_back(img2);
26
27
28 Stitcher stitcher = Stitcher::createDefault(try_use_gpu);
29 // 使用stitch函式進行拼接
30 Mat pano;
31 Stitcher::Status status = stitcher.stitch(imgs, pano);
32 if (status != Stitcher::OK)
33 {
34 cout << "Can't stitch images, error code = " << int(status) << endl;
35 return -1;
36 }
37 imwrite(result_name, pano);
38 Mat pano2 = pano.clone();
39 // 顯示源影象，和結果影象
40 imshow("全景影象", pano);
41 if (waitKey() == 27)
42 return 0;
43 }