【opencv+OpenMP】OpenMP并行编程应用—加速OpenCV图像拼接算法

OpenMP是一种应用于多处理器程序设计的并行编程处理方案，它提供了对于并行编程的高层抽象，只需要在程序中添加简单的指令，就可以编写高效的并行程序，而不用关心具体的并行实现细节，降低了并行编程的难度和复杂度。也正因为OpenMP的简单易用性，它并不适合于需要复杂的线程间同步和互斥的场合。

OpenCV中使用Sift或者Surf特征进行图像拼接的算法，需要分别对两幅或多幅图像进行特征提取和特征描述，之后再进行图像特征点的配对，图像变换等操作。不同图像的特征提取和描述的工作是整个过程中最耗费时间的，也是独立 运行的，可以使用OpenMP进行加速。

以下是不使用OpenMP加速的Sift图像拼接原程序：

1. #include "highgui/highgui.hpp"      
2. #include "opencv2/nonfree/nonfree.hpp"      
3. #include "opencv2/legacy/legacy.hpp"     
4. #include "omp.h"  
5.   
6. using namespace cv;  
7.   
8. //计算原始图像点位在经过矩阵变换后在目标图像上对应位置    
9. Point2f getTransformPoint(const Point2f originalPoint, const Mat &transformMaxtri);  
10.   
11. int main(int argc, char *argv[])  
12. {  
13.     float startTime = omp_get_wtime();  
14.   
15.     Mat image01 = imread("Test01.jpg");  
16.     Mat image02 = imread("Test02.jpg");  
17.     imshow("拼接图像1", image01);  
18.     imshow("拼接图像2", image02);  
19.   
20.     //灰度图转换    
21.     Mat image1, image2;  
22.     cvtColor(image01, image1, CV_RGB2GRAY);  
23.     cvtColor(image02, image2, CV_RGB2GRAY);  
24.   
25.     //提取特征点      
26.     SiftFeatureDetector siftDetector(800);  // 海塞矩阵阈值    
27.     vector<KeyPoint> keyPoint1, keyPoint2;  
28.     siftDetector.detect(image1, keyPoint1);  
29.     siftDetector.detect(image2, keyPoint2);  
30.   
31.     //特征点描述，为下边的特征点匹配做准备      
32.     SiftDescriptorExtractor siftDescriptor;  
33.     Mat imageDesc1, imageDesc2;  
34.     siftDescriptor.compute(image1, keyPoint1, imageDesc1);  
35.     siftDescriptor.compute(image2, keyPoint2, imageDesc2);  
36.   
37.     float endTime = omp_get_wtime();  
38.     std::cout << "不使用OpenMP加速消耗时间： " << endTime - startTime << std::endl;  
39.     //获得匹配特征点，并提取最优配对       
40.     FlannBasedMatcher matcher;  
41.     vector<DMatch> matchePoints;  
42.     matcher.match(imageDesc1, imageDesc2, matchePoints, Mat());  
43.     sort(matchePoints.begin(), matchePoints.end()); //特征点排序      
44.                                                     //获取排在前N个的最优匹配特征点    
45.     vector<Point2f> imagePoints1, imagePoints2;  
46.     for (int i = 0; i < 10; i++)  
47.     {  
48.         imagePoints1.push_back(keyPoint1[matchePoints[i].queryIdx].pt);  
49.         imagePoints2.push_back(keyPoint2[matchePoints[i].trainIdx].pt);  
50.     }  
51.   
52.     //获取图像1到图像2的投影映射矩阵，尺寸为3*3    
53.     Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);  
54.     Mat adjustMat = (Mat_<double>(3, 3) << 1.0, 0, image01.cols, 0, 1.0, 0, 0, 0, 1.0);  
55.     Mat adjustHomo = adjustMat*homo;  
56.   
57.     //获取最强配对点在原始图像和矩阵变换后图像上的对应位置，用于图像拼接点的定位    
58.     Point2f originalLinkPoint, targetLinkPoint, basedImagePoint;  
59.     originalLinkPoint = keyPoint1[matchePoints[0].queryIdx].pt;  
60.     targetLinkPoint = getTransformPoint(originalLinkPoint, adjustHomo);  
61.     basedImagePoint = keyPoint2[matchePoints[0].trainIdx].pt;  
62.   
63.     //图像配准    
64.     Mat imageTransform1;  
65.     warpPerspective(image01, imageTransform1, adjustMat*homo, Size(image02.cols + image01.cols + 110, image02.rows));  
66.   
67.     //在最强匹配点左侧的重叠区域进行累加，是衔接稳定过渡，消除突变    
68.     Mat image1Overlap, image2Overlap; //图1和图2的重叠部分       
69.     image1Overlap = imageTransform1(Rect(Point(targetLinkPoint.x - basedImagePoint.x, 0), Point(targetLinkPoint.x, image02.rows)));  
70.     image2Overlap = image02(Rect(0, 0, image1Overlap.cols, image1Overlap.rows));  
71.     Mat image1ROICopy = image1Overlap.clone();  //复制一份图1的重叠部分    
72.     for (int i = 0; i < image1Overlap.rows; i++)  
73.     {  
74.         for (int j = 0; j < image1Overlap.cols; j++)  
75.         {  
76.             double weight;  
77.             weight = (double)j / image1Overlap.cols;  //随距离改变而改变的叠加系数    
78.             image1Overlap.at<Vec3b>(i, j)[0] = (1 - weight)*image1ROICopy.at<Vec3b>(i, j)[0] + weight*image2Overlap.at<Vec3b>(i, j)[0];  
79.             image1Overlap.at<Vec3b>(i, j)[1] = (1 - weight)*image1ROICopy.at<Vec3b>(i, j)[1] + weight*image2Overlap.at<Vec3b>(i, j)[1];  
80.             image1Overlap.at<Vec3b>(i, j)[2] = (1 - weight)*image1ROICopy.at<Vec3b>(i, j)[2] + weight*image2Overlap.at<Vec3b>(i, j)[2];  
81.         }  
82.     }  
83.     Mat ROIMat = image02(Rect(Point(image1Overlap.cols, 0), Point(image02.cols, image02.rows)));  //图2中不重合的部分    
84.     ROIMat.copyTo(Mat(imageTransform1, Rect(targetLinkPoint.x, 0, ROIMat.cols, image02.rows))); //不重合的部分直接衔接上去    
85.     namedWindow("拼接结果", 0);  
86.     imshow("拼接结果", imageTransform1);  
87.     imwrite("D:\\拼接结果.jpg", imageTransform1);  
88.     waitKey();  
89.     return 0;  
90. }  
91.   
92. //计算原始图像点位在经过矩阵变换后在目标图像上对应位置    
93. Point2f getTransformPoint(const Point2f originalPoint, const Mat &transformMaxtri)  
94. {  
95.     Mat originelP, targetP;  
96.     originelP = (Mat_<double>(3, 1) << originalPoint.x, originalPoint.y, 1.0);  
97.     targetP = transformMaxtri*originelP;  
98.     float x = targetP.at<double>(0, 0) / targetP.at<double>(2, 0);  
99.     float y = targetP.at<double>(1, 0) / targetP.at<double>(2, 0);  
100.     return Point2f(x, y);  
101. } 
     

图像一：

图像二：

拼接结果 ：

在我的机器上不使用OpenMP平均耗时 4.7S。

使用OpenMP也很简单，VS 内置了对OpenMP的支持。在项目上右键->属性->配置属性->C/C++->语言->OpenMP支持里选择是：

之后在程序中加入OpenMP的头文件“omp.h”就可以了：

1. #include "highgui/highgui.hpp"      
2. #include "opencv2/nonfree/nonfree.hpp"      
3. #include "opencv2/legacy/legacy.hpp"     
4. #include "omp.h"  
5.   
6. using namespace cv;  
7.   
8. //计算原始图像点位在经过矩阵变换后在目标图像上对应位置    
9. Point2f getTransformPoint(const Point2f originalPoint, const Mat &transformMaxtri);  
10.   
11. int main(int argc, char *argv[])  
12. {  
13.     float startTime = omp_get_wtime();  
14.   
15.     Mat image01, image02;  
16.     Mat image1, image2;  
17.     vector<KeyPoint> keyPoint1, keyPoint2;  
18.     Mat imageDesc1, imageDesc2;  
19.     SiftFeatureDetector siftDetector(800);  // 海塞矩阵阈值    
20.     SiftDescriptorExtractor siftDescriptor;  
21.     //使用OpenMP的sections制导指令开启多线程  
22. #pragma omp parallel sections    
23.     {  
24. #pragma omp section    
25.         {  
26.             image01 = imread("Test01.jpg");  
27.             imshow("拼接图像1", image01);  
28.             //灰度图转换   
29.             cvtColor(image01, image1, CV_RGB2GRAY);  
30.             //提取特征点    
31.             siftDetector.detect(image1, keyPoint1);  
32.             //特征点描述，为下边的特征点匹配做准备      
33.             siftDescriptor.compute(image1, keyPoint1, imageDesc1);  
34.         }  
35. #pragma omp section    
36.         {  
37.             image02 = imread("Test02.jpg");  
38.             imshow("拼接图像2", image02);  
39.             cvtColor(image02, image2, CV_RGB2GRAY);  
40.             siftDetector.detect(image2, keyPoint2);  
41.             siftDescriptor.compute(image2, keyPoint2, imageDesc2);  
42.         }  
43.     }  
44.     float endTime = omp_get_wtime();  
45.     std::cout << "使用OpenMP加速消耗时间： " << endTime - startTime << std::endl;  
46.   
47.     //获得匹配特征点，并提取最优配对       
48.     FlannBasedMatcher matcher;  
49.     vector<DMatch> matchePoints;  
50.     matcher.match(imageDesc1, imageDesc2, matchePoints, Mat());  
51.     sort(matchePoints.begin(), matchePoints.end()); //特征点排序      
52.     //获取排在前N个的最优匹配特征点    
53.     vector<Point2f> imagePoints1, imagePoints2;  
54.     for (int i = 0; i < 10; i++)  
55.     {  
56.         imagePoints1.push_back(keyPoint1[matchePoints[i].queryIdx].pt);  
57.         imagePoints2.push_back(keyPoint2[matchePoints[i].trainIdx].pt);  
58.     }  
59.   
60.     //获取图像1到图像2的投影映射矩阵，尺寸为3*3    
61.     Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);  
62.     Mat adjustMat = (Mat_<double>(3, 3) << 1.0, 0, image01.cols, 0, 1.0, 0, 0, 0, 1.0);  
63.     Mat adjustHomo = adjustMat*homo;  
64.   
65.     //获取最强配对点在原始图像和矩阵变换后图像上的对应位置，用于图像拼接点的定位    
66.     Point2f originalLinkPoint, targetLinkPoint, basedImagePoint;  
67.     originalLinkPoint = keyPoint1[matchePoints[0].queryIdx].pt;  
68.     targetLinkPoint = getTransformPoint(originalLinkPoint, adjustHomo);  
69.     basedImagePoint = keyPoint2[matchePoints[0].trainIdx].pt;  
70.   
71.     //图像配准    
72.     Mat imageTransform1;  
73.     warpPerspective(image01, imageTransform1, adjustMat*homo, Size(image02.cols + image01.cols + 110, image02.rows));  
74.   
75.     //在最强匹配点左侧的重叠区域进行累加，是衔接稳定过渡，消除突变    
76.     Mat image1Overlap, image2Overlap; //图1和图2的重叠部分       
77.     image1Overlap = imageTransform1(Rect(Point(targetLinkPoint.x - basedImagePoint.x, 0), Point(targetLinkPoint.x, image02.rows)));  
78.     image2Overlap = image02(Rect(0, 0, image1Overlap.cols, image1Overlap.rows));  
79.     Mat image1ROICopy = image1Overlap.clone();  //复制一份图1的重叠部分   
80.     for (int i = 0; i < image1Overlap.rows; i++)  
81.     {  
82.         for (int j = 0; j < image1Overlap.cols; j++)  
83.         {  
84.             double weight;  
85.             weight = (double)j / image1Overlap.cols;  //随距离改变而改变的叠加系数    
86.             image1Overlap.at<Vec3b>(i, j)[0] = (1 - weight)*image1ROICopy.at<Vec3b>(i, j)[0] + weight*image2Overlap.at<Vec3b>(i, j)[0];  
87.             image1Overlap.at<Vec3b>(i, j)[1] = (1 - weight)*image1ROICopy.at<Vec3b>(i, j)[1] + weight*image2Overlap.at<Vec3b>(i, j)[1];  
88.             image1Overlap.at<Vec3b>(i, j)[2] = (1 - weight)*image1ROICopy.at<Vec3b>(i, j)[2] + weight*image2Overlap.at<Vec3b>(i, j)[2];  
89.         }  
90.     }  
91.     Mat ROIMat = image02(Rect(Point(image1Overlap.cols, 0), Point(image02.cols, image02.rows)));  //图2中不重合的部分    
92.     ROIMat.copyTo(Mat(imageTransform1, Rect(targetLinkPoint.x, 0, ROIMat.cols, image02.rows))); //不重合的部分直接衔接上去    
93.     namedWindow("拼接结果", 0);  
94.     imshow("拼接结果", imageTransform1);  
95.     imwrite("D:\\拼接结果.jpg", imageTransform1);  
96.     waitKey();  
97.     return 0;  
98. }  
99.   
100. //计算原始图像点位在经过矩阵变换后在目标图像上对应位置    
101. Point2f getTransformPoint(const Point2f originalPoint, const Mat &transformMaxtri)  
102. {  
103.     Mat originelP, targetP;  
104.     originelP = (Mat_<double>(3, 1) << originalPoint.x, originalPoint.y, 1.0);  
105.     targetP = transformMaxtri*originelP;  
106.     float x = targetP.at<double>(0, 0) / targetP.at<double>(2, 0);  
107.     float y = targetP.at<double>(1, 0) / targetP.at<double>(2, 0);  
108.     return Point2f(x, y);  
109. } 
     

OpenMP中for制导指令用于迭代计算的任务分配，sections制导指令用于非迭代计算的任务分配，每个#pragma ompsection 语句会引导一个线程。在上边的程序中相当于是两个线程分别执行两幅图像的特征提取和描述操作。使用OpenMP后平均耗时2.5S，速度差不多提升了一倍。