• 相机匹配点的选取(基于竖直直杆)

    上一篇博客已经进行霍夫直线检测的过程,那么之前的霍夫直线检测出来的直线进行拟合到一条直线之后有什么用呢?
    我的想法是进行直线拟合,就可以知道这条直线的表达式,通过提取相机匹配图像之中的匹配点距离这条直线的距离,从而提取出来最佳的匹配点.(当然这里只是我需要进行的,如果不是截取距离一条直线的距离,就不能这么用)

    最初的想法

    下面的代码的思路就是将左边提取出来的特征点,依次计算他们距离拟合直线的距离,得到的距离从小到达进行排序,依据排除的顺序,选取第一个和第八个大小的数值,作为提取出来的特殊匹配点,进行下面的操作.(整好跟之前的项目进行接轨)

    代码如下所示:

    1. #include 
    2. #include 
    3. #include 
    4. #include  
    5. #include   
    6. #include 
    7. #include 
    8. #include   
    9. #include   
    10.  
    11. using namespace cv;
    12. using namespace std;
    13. using namespace cv::xfeatures2d;
    14.  
    15. float K = 7.23106;
    16. float B = -8556.64;
    17. int main()
    18. {
    19. 	//创建检测器
    20. 	//cv::Ptr detector = SiftFeatureDetector::create();//sift
    21. 	Ptr detector = SurfFeatureDetector::create(100);//创建SIFT特征检测器，可改成SURF/ORB
    22. 	//Ptr descriptor_extractor = DescriptorExtractor::create("SURF");//创建特征向量生成器，可改成SURF/ORB
    23. 	Ptr descriptor_matcher = DescriptorMatcher::create("BruteForce");//创建特征匹配器  
    24. 	if (detector.empty())
    25. 		cout << "fail to create detector!";
    26.  
    27. 	//读入图像  
    28. 	Mat img1 = imread("左相机123.bmp", 0);
    29. 	Mat img2 = imread("右相机123.bmp", 0);
    30.  
    31. 	//特征点检测  
    32.  
    33. 	vector m_LeftKey, m_RightKey;
    34. 	detector->detect(img1, m_LeftKey);//检测img1中的SIFT特征点，存储到m_LeftKey中  
    35. 	detector->detect(img2, m_RightKey);
    36. 	cout << "图像1特征点个数:" << m_LeftKey.size() << endl;
    37. 	cout << "图像2特征点个数:" << m_RightKey.size() << endl;
    38.  
    39. 	vector key_points_1, key_points_2;
    40. 	cv::Mat dstImage1, dstImage2;
    41. 	detector->detectAndCompute(img1, Mat(), key_points_1, dstImage1);
    42. 	detector->detectAndCompute(img2, Mat(), key_points_2, dstImage2);
    43.  
    44. 	//根据特征点计算特征描述子矩阵，即特征向量矩阵  
    45.  
    46. 	double t = getTickCount();//当前滴答数 
    47. 	t = ((double)getTickCount() - t) / getTickFrequency();
    48. 	cout << "SIFT算法用时：" << t << "秒" << endl;
    49.  
    50. 	cout << "图像1特征描述矩阵大小：" << dstImage1.size()
    51. 		<< "，特征向量个数：" << dstImage1.rows << "，维数：" << dstImage1.cols << endl;
    52. 	cout << "图像2特征描述矩阵大小：" << dstImage2.size()
    53. 		<< "，特征向量个数：" << dstImage2.rows << "，维数：" << dstImage2.cols << endl;
    54.  
    55. 	//画出特征点  
    56. 	Mat img_m_LeftKey, img_m_RightKey;
    57. 	drawKeypoints(img1, m_LeftKey, img_m_LeftKey, Scalar::all(-1), 0);
    58. 	drawKeypoints(img2, m_RightKey, img_m_RightKey, Scalar::all(-1), 0);
    59. 	//imshow("Src1",img_m_LeftKey);  
    60. 	//imshow("Src2",img_m_RightKey);  
    61.  
    62. 	//特征匹配  
    63. 	vector matches;//匹配结果  
    64. 	descriptor_matcher->match(dstImage1, dstImage2, matches);//匹配两个图像的特征矩阵  
    65. 	cout << "Match个数：" << matches.size() << endl;
    66.  
    67. 	//计算匹配结果中距离的最大和最小值  
    68. 	//距离是指两个特征向量间的欧式距离，表明两个特征的差异，值越小表明两个特征点越接近  
    69. 	double max_dist = 0;
    70. 	double min_dist = 100;
    71. 	for (int i = 0; i < matches.size(); i++)
    72. 	{
    73. 		double dist = matches[i].distance;
    74. 		if (dist < min_dist) min_dist = dist;
    75. 		if (dist > max_dist) max_dist = dist;
    76. 	}
    77. 	cout << "最大距离：" << max_dist << endl;
    78. 	cout << "最小距离：" << min_dist << endl;
    79.  
    80. 	//筛选出较好的匹配点  
    81. 	vector goodMatches;
    82. 	for (int i = 0; i < matches.size(); i++)
    83. 	{
    84. 		if (matches[i].distance < 0.2 * max_dist)
    85. 		{
    86. 			goodMatches.push_back(matches[i]);
    87. 		}
    88. 	}
    89. 	cout << "goodMatch个数：" << goodMatches.size() << endl;
    90.  
    91. 	//画出匹配结果  
    92. 	Mat img_matches;
    93. 	//红色连接的是匹配的特征点对，绿色是未匹配的特征点  
    94. 	drawMatches(img1, m_LeftKey, img2, m_RightKey, goodMatches, img_matches,
    95. 		Scalar::all(-1), CV_RGB(0, 255, 0), Mat(), 2);
    96.  
    97. 	imshow("MatchSIFT", img_matches);
    98. 	imwrite("E:/项目使用版/合并版/Sift+RANSAC/Sift+RANSAC/MatchSIFT.jpg", img_matches);
    99. 	IplImage result = img_matches;
    100.  
    101. 	waitKey(0);
    102.  
    103.  
    104. 	//RANSAC匹配过程
    105. 	vector m_Matches = goodMatches;
    106.  
    107. 	// 分配空间
    108. 	int ptCount = (int)m_Matches.size();
    109. 	Mat p1(ptCount, 2, CV_32F);
    110. 	Mat p2(ptCount, 2, CV_32F);
    111.  
    112. 	// 把Keypoint转换为Mat
    113. 	Point2f pt;
    114. 	for (int i = 0; i < ptCount; i++)
    115. 	{
    116. 		pt = m_LeftKey[m_Matches[i].queryIdx].pt;
    117. 		p1.at<float>(i, 0) = pt.x;
    118. 		p1.at<float>(i, 1) = pt.y;
    119.  
    120. 		pt = m_RightKey[m_Matches[i].trainIdx].pt;
    121. 		p2.at<float>(i, 0) = pt.x;
    122. 		p2.at<float>(i, 1) = pt.y;
    123. 	}
    124.  
    125. 	// 用RANSAC方法计算F
    126. 	Mat m_Fundamental;
    127. 	vector m_RANSACStatus;       // 这个变量用于存储RANSAC后每个点的状态
    128. 	findFundamentalMat(p1, p2, m_RANSACStatus, FM_RANSAC);
    129.  
    130. 	// 计算野点个数
    131.  
    132. 	int OutlinerCount = 0;
    133. 	for (int i = 0; i < ptCount; i++)
    134. 	{
    135. 		if (m_RANSACStatus[i] == 0)    // 状态为0表示野点
    136. 		{
    137. 			OutlinerCount++;
    138. 		}
    139. 	}
    140. 	int InlinerCount = ptCount - OutlinerCount;   // 计算内点
    141. 	cout << "内点数为：" << InlinerCount << endl;
    142.  
    143.  
    144. 	// 这三个变量用于保存内点和匹配关系
    145. 	vector m_LeftInlier;
    146. 	vector m_RightInlier;
    147. 	vector m_InlierMatches;
    148.  
    149. 	m_InlierMatches.resize(InlinerCount);
    150. 	m_LeftInlier.resize(InlinerCount);
    151. 	m_RightInlier.resize(InlinerCount);
    152. 	InlinerCount = 0;
    153. 	float inlier_minRx = img1.cols;        //用于存储内点中右图最小横坐标，以便后续融合
    154.  
    155. 	float distance;//点到直线的距离公式
    156. 	for (int i = 0, j = 0; i < ptCount; i++)
    157. 	{
    158. 		if (m_RANSACStatus[i] != 0)
    159. 		{
    160.  
    161. 			m_LeftInlier[InlinerCount].x = p1.at<float>(i, 0);
    162. 			m_LeftInlier[InlinerCount].y = p1.at<float>(i, 1);
    163. 			m_RightInlier[InlinerCount].x = p2.at<float>(i, 0);
    164. 			m_RightInlier[InlinerCount].y = p2.at<float>(i, 1);
    165. 			m_InlierMatches[InlinerCount].queryIdx = InlinerCount;
    166. 			m_InlierMatches[InlinerCount].trainIdx = InlinerCount;
    167. 			cout << j << "左图像：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    168. 			cout << j << "右图像：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    169.  
    170.  
    171.  
    172. 			j++;
    173.  
    174. 			if (m_RightInlier[InlinerCount].x < inlier_minRx) inlier_minRx = m_RightInlier[InlinerCount].x;   //存储内点中右图最小横坐标
    175.  
    176. 			InlinerCount++;
    177. 		}
    178. 	}
    179.  
    180. 	// 把内点转换为drawMatches可以使用的格式
    181. 	vector key1(InlinerCount);
    182. 	vector key2(InlinerCount);
    183. 	KeyPoint::convert(m_LeftInlier, key1);
    184. 	KeyPoint::convert(m_RightInlier, key2);
    185.  
    186. 	// 显示计算F过后的内点匹配
    187. 	Mat OutImage;
    188. 	drawMatches(img1, key1, img2, key2, m_InlierMatches, OutImage);
    189. 	cvNamedWindow("Match features", 1);
    190. 	cvShowImage("Match features", &IplImage(OutImage));
    191. 	waitKey(0);
    192.  
    193. 	
    194.  
    195.  
    196.  
    197. 	return 0;
    198. }

    进行匹配之后的图像:

    挑选的自己想要的点:看到上面的点就是出现了问题,就是匹配的时候,针对于自己想要的点没有匹配好.

    这个地方对上一个博客之中那个竖直检测的代码进行了修改,发现了一些问题.

    对相机的焦距进行了调整之后,可以得到如下匹配图,效果就是跟之前相比,匹配点是多了很多.

    但是发现上上面的那个图并不是我们想要的点,因为对比下面的这条直线,明显结果是错误的.

    点到直线的距离公式如下所示:

    对于点到直线的距离对于特征点进行评价,找出符合要求自己想要的点.对于算法再次进行改进,分为垂直和不垂直两种情况进行分别探讨.使用一个vertical标志进行表征,相应的代码如下所示:

    1. #include 
    2. #include 
    3. #include 
    4. #include  
    5. #include   
    6. #include 
    7. #include 
    8. #include   
    9. #include   
    10.  
    11. using namespace cv;
    12. using namespace std;
    13. using namespace cv::xfeatures2d;
    14. /*
    15. void BubbleSort1(float arr[], int length) {//从大到小排序
    16. 	float temp;
    17. 	for (int i = 0; i < length - 1; i++) {//最外层循环，一共运行数组长度-1次，代表了一共要比较的次数
    18. 		for (int j = length - 1; j > i; j--) {//每次循环代表了找出每次的最大值。
    19. 			if (arr[j] > arr[j - 1]) {
    20. 				temp = arr[j];
    21. 				arr[j] = arr[j - 1];
    22. 				arr[j - 1] = temp;
    23. 			}
    24. 		}
    25. 	}
    26. }
    27. */
    28. void BubbleSort1(float arr[], int length) {//从小到大排序
    29. 	float temp;
    30. 	for (int i = 0; i < length - 1; i++) {
    31. 		for (int j = length - 1; j > i; j--) {
    32. 			if (arr[j] < arr[j - 1]) {
    33. 				temp = arr[j];
    34. 				arr[j] = arr[j - 1];
    35. 				arr[j - 1] = temp;
    36. 			}
    37. 		}
    38. 	}
    39. }
    40.  
    41. bool vertical = true;
    42. float K = 10000000;
    43. float B = 1763;
    44. int main()
    45. {
    46. 	//创建检测器
    47. 	//cv::Ptr detector = SiftFeatureDetector::create();//sift
    48. 	Ptr detector = SurfFeatureDetector::create(100);//创建SIFT特征检测器，可改成SURF/ORB
    49. 	//Ptr descriptor_extractor = DescriptorExtractor::create("SURF");//创建特征向量生成器，可改成SURF/ORB
    50. 	Ptr descriptor_matcher = DescriptorMatcher::create("BruteForce");//创建特征匹配器  
    51. 	if (detector.empty())
    52. 		cout << "fail to create detector!";
    53.  
    54. 	//读入图像  
    55. 	Mat img1 = imread("左相机123.bmp", 0);
    56. 	Mat img2 = imread("右相机123.bmp", 0);
    57. 	Mat combine;
    58. 	hconcat(img1, img2, combine); //横向拼接
    59.  
    60. 	//特征点检测  
    61.  
    62. 	vector m_LeftKey, m_RightKey;
    63. 	detector->detect(img1, m_LeftKey);//检测img1中的SIFT特征点，存储到m_LeftKey中  
    64. 	detector->detect(img2, m_RightKey);
    65. 	cout << "图像1特征点个数:" << m_LeftKey.size() << endl;
    66. 	cout << "图像2特征点个数:" << m_RightKey.size() << endl;
    67.  
    68. 	vector key_points_1, key_points_2;
    69. 	cv::Mat dstImage1, dstImage2;
    70. 	detector->detectAndCompute(img1, Mat(), key_points_1, dstImage1);
    71. 	detector->detectAndCompute(img2, Mat(), key_points_2, dstImage2);
    72.  
    73. 	//根据特征点计算特征描述子矩阵，即特征向量矩阵  
    74.  
    75. 	double t = getTickCount();//当前滴答数 
    76. 	t = ((double)getTickCount() - t) / getTickFrequency();
    77. 	cout << "SIFT算法用时：" << t << "秒" << endl;
    78.  
    79. 	cout << "图像1特征描述矩阵大小：" << dstImage1.size()
    80. 		<< "，特征向量个数：" << dstImage1.rows << "，维数：" << dstImage1.cols << endl;
    81. 	cout << "图像2特征描述矩阵大小：" << dstImage2.size()
    82. 		<< "，特征向量个数：" << dstImage2.rows << "，维数：" << dstImage2.cols << endl;
    83.  
    84. 	//画出特征点  
    85. 	Mat img_m_LeftKey, img_m_RightKey;
    86. 	drawKeypoints(img1, m_LeftKey, img_m_LeftKey, Scalar::all(-1), 0);
    87. 	drawKeypoints(img2, m_RightKey, img_m_RightKey, Scalar::all(-1), 0);
    88. 	//imshow("Src1",img_m_LeftKey);  
    89. 	//imshow("Src2",img_m_RightKey);  
    90.  
    91. 	//特征匹配  
    92. 	vector matches;//匹配结果  
    93. 	descriptor_matcher->match(dstImage1, dstImage2, matches);//匹配两个图像的特征矩阵  
    94. 	cout << "Match个数：" << matches.size() << endl;
    95.  
    96. 	//计算匹配结果中距离的最大和最小值  
    97. 	//距离是指两个特征向量间的欧式距离，表明两个特征的差异，值越小表明两个特征点越接近  
    98. 	double max_dist = 0;
    99. 	double min_dist = 300;
    100. 	for (int i = 0; i < matches.size(); i++)
    101. 	{
    102. 		double dist = matches[i].distance;
    103. 		if (dist < min_dist) min_dist = dist;
    104. 		if (dist > max_dist) max_dist = dist;
    105. 	}
    106. 	cout << "最大距离：" << max_dist << endl;
    107. 	cout << "最小距离：" << min_dist << endl;
    108.  
    109. 	//筛选出较好的匹配点  
    110. 	vector goodMatches;
    111. 	for (int i = 0; i < matches.size(); i++)
    112. 	{
    113. 		if (matches[i].distance < 0.2 * max_dist)
    114. 		{
    115. 			goodMatches.push_back(matches[i]);
    116. 		}
    117. 	}
    118. 	cout << "goodMatch个数：" << goodMatches.size() << endl;
    119.  
    120. 	//画出匹配结果  
    121. 	Mat img_matches;
    122. 	//红色连接的是匹配的特征点对，绿色是未匹配的特征点  
    123. 	drawMatches(img1, m_LeftKey, img2, m_RightKey, goodMatches, img_matches,
    124. 		Scalar::all(-1), CV_RGB(0, 255, 0), Mat(), 2);
    125.  
    126. 	imshow("MatchSIFT", img_matches);
    127. 	imwrite("MatchSIFT.jpg", img_matches);
    128. 	IplImage result = img_matches;
    129.  
    130. 	waitKey(0);
    131.  
    132.  
    133. 	//RANSAC匹配过程
    134. 	vector m_Matches = goodMatches;
    135.  
    136. 	// 分配空间
    137. 	int ptCount = (int)m_Matches.size();
    138. 	Mat p1(ptCount, 2, CV_32F);
    139. 	Mat p2(ptCount, 2, CV_32F);
    140.  
    141. 	// 把Keypoint转换为Mat
    142. 	Point2f pt;
    143. 	for (int i = 0; i < ptCount; i++)
    144. 	{
    145. 		pt = m_LeftKey[m_Matches[i].queryIdx].pt;
    146. 		p1.at<float>(i, 0) = pt.x;
    147. 		p1.at<float>(i, 1) = pt.y;
    148.  
    149. 		pt = m_RightKey[m_Matches[i].trainIdx].pt;
    150. 		p2.at<float>(i, 0) = pt.x;
    151. 		p2.at<float>(i, 1) = pt.y;
    152. 	}
    153.  
    154. 	// 用RANSAC方法计算F
    155. 	Mat m_Fundamental;
    156. 	vector m_RANSACStatus;       // 这个变量用于存储RANSAC后每个点的状态
    157. 	findFundamentalMat(p1, p2, m_RANSACStatus, FM_RANSAC);
    158.  
    159. 	// 计算野点个数
    160.  
    161. 	int OutlinerCount = 0;
    162. 	for (int i = 0; i < ptCount; i++)
    163. 	{
    164. 		if (m_RANSACStatus[i] == 0)    // 状态为0表示野点
    165. 		{
    166. 			OutlinerCount++;
    167. 		}
    168. 	}
    169. 	int InlinerCount = ptCount - OutlinerCount;   // 计算内点
    170. 	cout << "内点数为：" << InlinerCount << endl;
    171.  
    172.  
    173. 	// 这三个变量用于保存内点和匹配关系
    174. 	vector m_LeftInlier;
    175. 	vector m_RightInlier;
    176. 	vector m_InlierMatches;
    177.  
    178. 	m_InlierMatches.resize(InlinerCount);
    179. 	m_LeftInlier.resize(InlinerCount);
    180. 	m_RightInlier.resize(InlinerCount);
    181. 	InlinerCount = 0;
    182. 	float inlier_minRx = img1.cols;        //用于存储内点中右图最小横坐标，以便后续融合
    183.  
    184. 	float distance = 0;//点到直线的距离公式
    185.  
    186. 	
    187. 	float point[80];//声明一个数组,用来存放80个数组,也就是80个数值距离,里面可能是存在0元素的
    188. 	for (int i = 0, j = 0; i < ptCount; i++)
    189. 	{
    190. 		if (m_RANSACStatus[i] != 0)
    191. 		{
    192.  
    193. 			m_LeftInlier[InlinerCount].x = p1.at<float>(i, 0);
    194. 			m_LeftInlier[InlinerCount].y = p1.at<float>(i, 1);
    195. 			m_RightInlier[InlinerCount].x = p2.at<float>(i, 0);
    196. 			m_RightInlier[InlinerCount].y = p2.at<float>(i, 1);
    197. 			m_InlierMatches[InlinerCount].queryIdx = InlinerCount;
    198. 			m_InlierMatches[InlinerCount].trainIdx = InlinerCount;
    199. 			cout << j << "左图像：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    200. 			cout << j << "右图像：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    201.  
    202. 			if ( vertical == false )
    203. 			{
    204. 				if (j < 80)
    205. 				{
    206. 					cout << "j:" << j << endl;
    207. 					point[j] = (float)abs((K * m_LeftInlier[InlinerCount].x + B - m_LeftInlier[InlinerCount].y) / sqrt(K * K + 1 * 1));
    208. 					cout << "(K * m_LeftInlier[InlinerCount].x + B - m_LeftInlier[InlinerCount].y)" << (K * m_LeftInlier[InlinerCount].x + B - m_LeftInlier[InlinerCount].y) << endl;
    209. 					cout << "sqrt(K * K + 1 * 1)" << sqrt(K * K + 1 * 1) << endl;
    210. 					cout << "point[j]:" << point[j] << endl;
    211. 				}
    212.  
    213. 			}
    214. 			else {
    215. 				if (j < 80)
    216. 				{
    217. 					cout << "j:" << j << endl;
    218. 					point[j] = (float)abs(( m_LeftInlier[InlinerCount].x - B));
    219. 					cout << "(m_LeftInlier[InlinerCount].x)" << m_LeftInlier[InlinerCount].x << endl;
    220. 					cout << "point[j]:" << point[j] << endl;
    221. 				}
    222. 			}
    223. 			
    224. 			j++;
    225.  
    226. 			if (m_RightInlier[InlinerCount].x < inlier_minRx) inlier_minRx = m_RightInlier[InlinerCount].x;   //存储内点中右图最小横坐标
    227.  
    228. 			InlinerCount++;
    229. 		    
    230. 		}
    231. 	
    232. 	}
    233. 	// 把内点转换为drawMatches可以使用的格式
    234. 	vector key1(InlinerCount);
    235. 	vector key2(InlinerCount);
    236. 	KeyPoint::convert(m_LeftInlier, key1);
    237. 	KeyPoint::convert(m_RightInlier, key2);
    238.  
    239. 	// 显示计算F过后的内点匹配
    240. 	Mat OutImage;
    241. 	drawMatches(img1, key1, img2, key2, m_InlierMatches, OutImage);
    242. 	imwrite("test1.bmp", OutImage);
    243. 	cvNamedWindow("Match features better", 1);
    244. 	cvShowImage("Match features better ", &IplImage(OutImage));
    245. 	waitKey(0);
    246.  
    247. 	BubbleSort1(point, 80);//将上面的距离进行了排序,从小进行排序
    248. 	float pointselect[8];//
    249. 	int select = 0;
    250. 	for (int i = 0; i < 80; i++)//提出为0的距离,从小到大选出8个数值
    251. 	{
    252. 		if (point[i]  > 0.5 )
    253. 		{
    254. 			pointselect[select] = point[i];
    255. 			cout << "select元素:" << pointselect[select] << endl;
    256. 			select++;
    257. 			if (select == 8)
    258. 			{
    259. 				break;
    260. 			}
    261. 		}
    262. 	}
    263. 	cout << "select:" << select << endl;
    264.  
    265. 	
    266.  
    267. 	
    268.  
    269. 	/****************************************************************************************************/
    270.  
    271.  
    272. 	//这里我们接下来就是选取几个数值之中距离最小和最大的.
    273. 	m_InlierMatches.resize(InlinerCount);
    274. 	m_LeftInlier.resize(InlinerCount);
    275. 	m_RightInlier.resize(InlinerCount);
    276. 	InlinerCount = 0;
    277.     inlier_minRx = img1.cols;        //用于存储内点中右图最小横坐标，以便后续融合
    278. 	for (int i = 0, j = 0; i < ptCount; i++)
    279. 	{
    280. 		if (m_RANSACStatus[i] != 0)
    281. 		{
    282.  
    283. 			m_LeftInlier[InlinerCount].x = p1.at<float>(i, 0);
    284. 			m_LeftInlier[InlinerCount].y = p1.at<float>(i, 1);
    285. 			m_RightInlier[InlinerCount].x = p2.at<float>(i, 0);
    286. 			m_RightInlier[InlinerCount].y = p2.at<float>(i, 1);
    287. 			m_InlierMatches[InlinerCount].queryIdx = InlinerCount;
    288. 			m_InlierMatches[InlinerCount].trainIdx = InlinerCount;
    289. 			//cout << j << "左图像：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    290. 			//cout << j << "右图像：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    291.  
    292. 			j++;
    293. 			if (vertical == false)
    294. 			{
    295. 				if ((float)abs((K*m_LeftInlier[InlinerCount].x + B - m_LeftInlier[InlinerCount].y) / sqrt(K * K + 1 * 1)) == pointselect[0])//最小点
    296. 				{
    297. 					cout << j << "左图像选出的点1：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    298. 					cout << j << "右图像选出的点1：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    299.  
    300. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    301. 				}
    302. 				if ((float)abs((K*m_LeftInlier[InlinerCount].x + B - m_LeftInlier[InlinerCount].y) / sqrt(K * K + 1 * 1)) == pointselect[7])//最大点
    303. 				{
    304. 					cout << j << "左图像选出的点2：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    305. 					cout << j << "右图像选出的点2：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    306. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    307. 				}
    308. 			}
    309. 			else
    310. 			{
    311. 				if ((float)abs(m_LeftInlier[InlinerCount].x - B) == pointselect[0])//最小点
    312. 				{
    313. 					cout << j << "左图像选出的点1：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    314. 					cout << j << "右图像选出的点1：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    315.  
    316. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    317. 				}
    318. 				if ((float)abs(m_LeftInlier[InlinerCount].x - B)== pointselect[7])//最大点
    319. 				{
    320. 					cout << j << "左图像选出的点2：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    321. 					cout << j << "右图像选出的点2：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    322. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    323. 				}
    324. 			}
    325.  
    326. 			if (m_RightInlier[InlinerCount].x < inlier_minRx) inlier_minRx = m_RightInlier[InlinerCount].x;   //存储内点中右图最小横坐标
    327.  
    328. 			InlinerCount++;
    329.  
    330. 		}
    331.  
    332. 	}
    333.  
    334. 	imwrite("combine.bmp",combine);
    335. 	resize(combine, combine, Size(1024, 540));//显示改变大小
    336. 	imshow("输出想要的匹配点", combine);
    337. 	waitKey(0);
    338.  
    339. 	return 0;
    340. }

    最终得到的输出点是如下所示:

    可见上面的点是比较正常的.

    提取点到直线的垂足

    (对上面的代码再次进行迭代)
    点到直线的垂足公式,这个地方是比较容易推导的,下面是我自己进行推导的过程.

    还是要提前进行情况的分析,①不垂直的情况是可以用上面的公式进行表征;②垂直的情况, 

    基于上述的代码再次进行分析. 

    1. #include 
    2. #include 
    3. #include 
    4. #include  
    5. #include   
    6. #include 
    7. #include 
    8. #include   
    9. #include   
    10.  
    11. using namespace cv;
    12. using namespace std;
    13. using namespace cv::xfeatures2d;
    14. /*
    15. void BubbleSort1(float arr[], int length) {//从大到小排序
    16. 	float temp;
    17. 	for (int i = 0; i < length - 1; i++) {//最外层循环，一共运行数组长度-1次，代表了一共要比较的次数
    18. 		for (int j = length - 1; j > i; j--) {//每次循环代表了找出每次的最大值。
    19. 			if (arr[j] > arr[j - 1]) {
    20. 				temp = arr[j];
    21. 				arr[j] = arr[j - 1];
    22. 				arr[j - 1] = temp;
    23. 			}
    24. 		}
    25. 	}
    26. }
    27. */
    28. void BubbleSort1(float arr[], int length) {//从小到大排序
    29. 	float temp;
    30. 	for (int i = 0; i < length - 1; i++) {
    31. 		for (int j = length - 1; j > i; j--) {
    32. 			if (arr[j] < arr[j - 1]) {
    33. 				temp = arr[j];
    34. 				arr[j] = arr[j - 1];
    35. 				arr[j - 1] = temp;
    36. 			}
    37. 		}
    38. 	}
    39. }
    40. float xll1, xrr1, yll1, yrr1;
    41. float xll2, xrr2, yll2, yrr2;
    42.  
    43. bool vertical1 = true;
    44. float K1 = 10000000;
    45. float B1 = 1763;
    46.  
    47. bool vertical2 = false;
    48. float K2= -6.11746;
    49. float B2 = 4138.73;
    50.  
    51. int main()
    52. {
    53. 	//创建检测器
    54. 	//cv::Ptr detector = SiftFeatureDetector::create();//sift
    55. 	Ptr detector = SurfFeatureDetector::create(100);//创建SIFT特征检测器，可改成SURF/ORB
    56. 	//Ptr descriptor_extractor = DescriptorExtractor::create("SURF");//创建特征向量生成器，可改成SURF/ORB
    57. 	Ptr descriptor_matcher = DescriptorMatcher::create("BruteForce");//创建特征匹配器  
    58. 	if (detector.empty())
    59. 		cout << "fail to create detector!";
    60.  
    61. 	//读入图像  
    62. 	Mat img1 = imread("左相机123.bmp", 0);
    63. 	Mat img2 = imread("右相机123.bmp", 0);
    64. 	Mat combine;
    65. 	hconcat(img1, img2, combine); //横向拼接
    66.  
    67. 	//特征点检测  
    68.  
    69. 	vector m_LeftKey, m_RightKey;
    70. 	detector->detect(img1, m_LeftKey);//检测img1中的SIFT特征点，存储到m_LeftKey中  
    71. 	detector->detect(img2, m_RightKey);
    72. 	cout << "图像1特征点个数:" << m_LeftKey.size() << endl;
    73. 	cout << "图像2特征点个数:" << m_RightKey.size() << endl;
    74.  
    75. 	vector key_points_1, key_points_2;
    76. 	cv::Mat dstImage1, dstImage2;
    77. 	detector->detectAndCompute(img1, Mat(), key_points_1, dstImage1);
    78. 	detector->detectAndCompute(img2, Mat(), key_points_2, dstImage2);
    79.  
    80. 	//根据特征点计算特征描述子矩阵，即特征向量矩阵  
    81.  
    82. 	double t = getTickCount();//当前滴答数 
    83. 	t = ((double)getTickCount() - t) / getTickFrequency();
    84. 	cout << "SIFT算法用时：" << t << "秒" << endl;
    85.  
    86. 	cout << "图像1特征描述矩阵大小：" << dstImage1.size()
    87. 		<< "，特征向量个数：" << dstImage1.rows << "，维数：" << dstImage1.cols << endl;
    88. 	cout << "图像2特征描述矩阵大小：" << dstImage2.size()
    89. 		<< "，特征向量个数：" << dstImage2.rows << "，维数：" << dstImage2.cols << endl;
    90.  
    91. 	//画出特征点  
    92. 	Mat img_m_LeftKey, img_m_RightKey;
    93. 	drawKeypoints(img1, m_LeftKey, img_m_LeftKey, Scalar::all(-1), 0);
    94. 	drawKeypoints(img2, m_RightKey, img_m_RightKey, Scalar::all(-1), 0);
    95. 	//imshow("Src1",img_m_LeftKey);  
    96. 	//imshow("Src2",img_m_RightKey);  
    97.  
    98. 	//特征匹配  
    99. 	vector matches;//匹配结果  
    100. 	descriptor_matcher->match(dstImage1, dstImage2, matches);//匹配两个图像的特征矩阵  
    101. 	cout << "Match个数：" << matches.size() << endl;
    102.  
    103. 	//计算匹配结果中距离的最大和最小值  
    104. 	//距离是指两个特征向量间的欧式距离，表明两个特征的差异，值越小表明两个特征点越接近  
    105. 	double max_dist = 0;
    106. 	double min_dist = 300;
    107. 	for (int i = 0; i < matches.size(); i++)
    108. 	{
    109. 		double dist = matches[i].distance;
    110. 		if (dist < min_dist) min_dist = dist;
    111. 		if (dist > max_dist) max_dist = dist;
    112. 	}
    113. 	cout << "最大距离：" << max_dist << endl;
    114. 	cout << "最小距离：" << min_dist << endl;
    115.  
    116. 	//筛选出较好的匹配点  
    117. 	vector goodMatches;
    118. 	for (int i = 0; i < matches.size(); i++)
    119. 	{
    120. 		if (matches[i].distance < 0.2 * max_dist)
    121. 		{
    122. 			goodMatches.push_back(matches[i]);
    123. 		}
    124. 	}
    125. 	cout << "goodMatch个数：" << goodMatches.size() << endl;
    126.  
    127. 	//画出匹配结果  
    128. 	Mat img_matches;
    129. 	//红色连接的是匹配的特征点对，绿色是未匹配的特征点  
    130. 	drawMatches(img1, m_LeftKey, img2, m_RightKey, goodMatches, img_matches,
    131. 		Scalar::all(-1), CV_RGB(0, 255, 0), Mat(), 2);
    132.  
    133. 	imshow("MatchSIFT", img_matches);
    134. 	imwrite("MatchSIFT.jpg", img_matches);
    135. 	IplImage result = img_matches;
    136.  
    137. 	waitKey(0);
    138.  
    139.  
    140. 	//RANSAC匹配过程
    141. 	vector m_Matches = goodMatches;
    142.  
    143. 	// 分配空间
    144. 	int ptCount = (int)m_Matches.size();
    145. 	Mat p1(ptCount, 2, CV_32F);
    146. 	Mat p2(ptCount, 2, CV_32F);
    147.  
    148. 	// 把Keypoint转换为Mat
    149. 	Point2f pt;
    150. 	for (int i = 0; i < ptCount; i++)
    151. 	{
    152. 		pt = m_LeftKey[m_Matches[i].queryIdx].pt;
    153. 		p1.at<float>(i, 0) = pt.x;
    154. 		p1.at<float>(i, 1) = pt.y;
    155.  
    156. 		pt = m_RightKey[m_Matches[i].trainIdx].pt;
    157. 		p2.at<float>(i, 0) = pt.x;
    158. 		p2.at<float>(i, 1) = pt.y;
    159. 	}
    160.  
    161. 	// 用RANSAC方法计算F
    162. 	Mat m_Fundamental;
    163. 	vector m_RANSACStatus;       // 这个变量用于存储RANSAC后每个点的状态
    164. 	findFundamentalMat(p1, p2, m_RANSACStatus, FM_RANSAC);
    165.  
    166. 	// 计算野点个数
    167.  
    168. 	int OutlinerCount = 0;
    169. 	for (int i = 0; i < ptCount; i++)
    170. 	{
    171. 		if (m_RANSACStatus[i] == 0)    // 状态为0表示野点
    172. 		{
    173. 			OutlinerCount++;
    174. 		}
    175. 	}
    176. 	int InlinerCount = ptCount - OutlinerCount;   // 计算内点
    177. 	cout << "内点数为：" << InlinerCount << endl;
    178.  
    179.  
    180. 	// 这三个变量用于保存内点和匹配关系
    181. 	vector m_LeftInlier;
    182. 	vector m_RightInlier;
    183. 	vector m_InlierMatches;
    184.  
    185. 	m_InlierMatches.resize(InlinerCount);
    186. 	m_LeftInlier.resize(InlinerCount);
    187. 	m_RightInlier.resize(InlinerCount);
    188. 	InlinerCount = 0;
    189. 	float inlier_minRx = img1.cols;        //用于存储内点中右图最小横坐标，以便后续融合
    190.  
    191. 	float distance = 0;//点到直线的距离公式
    192.  
    193. 	
    194. 	float point[80];//声明一个数组,用来存放80个数组,也就是80个数值距离,里面可能是存在0元素的
    195. 	for (int i = 0, j = 0; i < ptCount; i++)
    196. 	{
    197. 		if (m_RANSACStatus[i] != 0)
    198. 		{
    199.  
    200. 			m_LeftInlier[InlinerCount].x = p1.at<float>(i, 0);
    201. 			m_LeftInlier[InlinerCount].y = p1.at<float>(i, 1);
    202. 			m_RightInlier[InlinerCount].x = p2.at<float>(i, 0);
    203. 			m_RightInlier[InlinerCount].y = p2.at<float>(i, 1);
    204. 			m_InlierMatches[InlinerCount].queryIdx = InlinerCount;
    205. 			m_InlierMatches[InlinerCount].trainIdx = InlinerCount;
    206. 			cout << j << "左图像：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    207. 			cout << j << "右图像：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    208.  
    209. 			if ( vertical1 == false )
    210. 			{
    211. 				if (j < 80)
    212. 				{
    213. 					cout << "j:" << j << endl;
    214. 					point[j] = (float)abs((K1 * m_LeftInlier[InlinerCount].x + B1 - m_LeftInlier[InlinerCount].y) / sqrt(K1 * K1 + 1 * 1));
    215. 					cout << "(K1 * m_LeftInlier[InlinerCount].x + B1 - m_LeftInlier[InlinerCount].y)" << (K1 * m_LeftInlier[InlinerCount].x + B1 - m_LeftInlier[InlinerCount].y) << endl;
    216. 					cout << "sqrt(K1 * K1 + 1 * 1)" << sqrt(K1 * K1 + 1 * 1) << endl;
    217. 					cout << "point[j]:" << point[j] << endl;
    218. 				}
    219.  
    220. 			}
    221. 			else {
    222. 				if (j < 80)
    223. 				{
    224. 					cout << "j:" << j << endl;
    225. 					point[j] = (float)abs(( m_LeftInlier[InlinerCount].x - B1));
    226. 					cout << "(m_LeftInlier[InlinerCount].x)" << m_LeftInlier[InlinerCount].x << endl;
    227. 					cout << "point[j]:" << point[j] << endl;
    228. 				}
    229. 			}
    230. 			
    231. 			j++;
    232.  
    233. 			if (m_RightInlier[InlinerCount].x < inlier_minRx) inlier_minRx = m_RightInlier[InlinerCount].x;   //存储内点中右图最小横坐标
    234.  
    235. 			InlinerCount++;
    236. 		    
    237. 		}
    238. 	
    239. 	}
    240. 	// 把内点转换为drawMatches可以使用的格式
    241. 	vector key1(InlinerCount);
    242. 	vector key2(InlinerCount);
    243. 	KeyPoint::convert(m_LeftInlier, key1);
    244. 	KeyPoint::convert(m_RightInlier, key2);
    245.  
    246. 	// 显示计算F过后的内点匹配
    247. 	Mat OutImage;
    248. 	drawMatches(img1, key1, img2, key2, m_InlierMatches, OutImage);
    249. 	imwrite("test1.bmp", OutImage);
    250. 	cvNamedWindow("Match features better", 1);
    251. 	cvShowImage("Match features better ", &IplImage(OutImage));
    252. 	waitKey(0);
    253.  
    254. 	BubbleSort1(point, 80);//将上面的距离进行了排序,从小进行排序
    255. 	float pointselect[8];//
    256. 	int select = 0;
    257. 	for (int i = 0; i < 80; i++)//提出为0的距离,从小到大选出8个数值
    258. 	{
    259. 		if (point[i]  > 0.5 )
    260. 		{
    261. 			pointselect[select] = point[i];
    262. 			cout << "select元素:" << pointselect[select] << endl;
    263. 			select++;
    264. 			if (select == 8)
    265. 			{
    266. 				break;
    267. 			}
    268. 		}
    269. 	}
    270. 	cout << "select:" << select << endl;
    271.  
    272. 	
    273.  
    274. 	
    275.  
    276. 	/****************************************************************************************************/
    277.  
    278.  
    279. 	//这里我们接下来就是选取几个数值之中距离最小和最大的.
    280. 	m_InlierMatches.resize(InlinerCount);
    281. 	m_LeftInlier.resize(InlinerCount);
    282. 	m_RightInlier.resize(InlinerCount);
    283. 	InlinerCount = 0;
    284.     inlier_minRx = img1.cols;        //用于存储内点中右图最小横坐标，以便后续融合
    285. 	for (int i = 0, j = 0; i < ptCount; i++)
    286. 	{
    287. 		if (m_RANSACStatus[i] != 0)
    288. 		{
    289.  
    290. 			m_LeftInlier[InlinerCount].x = p1.at<float>(i, 0);
    291. 			m_LeftInlier[InlinerCount].y = p1.at<float>(i, 1);
    292. 			m_RightInlier[InlinerCount].x = p2.at<float>(i, 0);
    293. 			m_RightInlier[InlinerCount].y = p2.at<float>(i, 1);
    294. 			m_InlierMatches[InlinerCount].queryIdx = InlinerCount;
    295. 			m_InlierMatches[InlinerCount].trainIdx = InlinerCount;
    296. 			//cout << j << "左图像：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    297. 			//cout << j << "右图像：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    298.  
    299. 			j++;
    300. 			if (vertical1 == false && vertical2 == false)//直线1 和直线2都不垂直
    301. 			{
    302. 				if ((float)abs((K1*m_LeftInlier[InlinerCount].x + B1 - m_LeftInlier[InlinerCount].y) / sqrt(K1 * K1 + 1 * 1)) == pointselect[0])//最小点
    303. 				{
    304. 					//匹配点
    305. 					cout << j << "左图像选出的点1：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    306. 					cout << j << "右图像选出的点1：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    307. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    308. 				
    309. 					//垂足
    310. 					xll1 = (float)(m_LeftInlier[InlinerCount].x + K1 * m_LeftInlier[InlinerCount].y - K1 * B1) / (K1 * K1 + 1);
    311. 					yll1 = (float)(K1 * m_LeftInlier[InlinerCount].x + K1 * K1 * m_LeftInlier[InlinerCount].y + B1) / (K1 * K1 + 1);
    312.  
    313. 					xrr1 = (float)(m_RightInlier[InlinerCount].x + K2 * m_RightInlier[InlinerCount].y - K2 * B2) / (K2 * K2 + 1);
    314. 					yrr1 = (float)(K2 * m_RightInlier[InlinerCount].x + K2 * K2 * m_RightInlier[InlinerCount].y + B2) / (K2 * K2 + 1);
    315. 				
    316. 				}
    317. 				if ((float)abs((K1*m_LeftInlier[InlinerCount].x + B1 - m_LeftInlier[InlinerCount].y) / sqrt(K1 * K1 + 1 * 1)) == pointselect[7])//最大点
    318. 				{
    319. 					cout << j << "左图像选出的点2：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    320. 					cout << j << "右图像选出的点2：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    321. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    322. 				
    323. 				    //垂足
    324. 					xll2 = (float)(m_LeftInlier[InlinerCount].x + K1 * m_LeftInlier[InlinerCount].y - K1 * B1) / (K1 * K1 + 1);
    325. 					yll2 = (float)(K1 * m_LeftInlier[InlinerCount].x + K1 * K1 * m_LeftInlier[InlinerCount].y + B1) / (K1 * K1 + 1);
    326.  
    327. 					xrr2 = (float)(m_RightInlier[InlinerCount].x + K2 * m_RightInlier[InlinerCount].y - K2 * B2) / (K2 * K2 + 1);
    328. 					yrr2 = (float)(K2 * m_RightInlier[InlinerCount].x + K2 * K2 * m_RightInlier[InlinerCount].y + B2) / (K2 * K2 + 1);
    329. 				}
    330. 			}
    331. 			else if (vertical1 == true && vertical2 == true) //直线1和直线2都垂直
    332. 			{
    333. 				if ((float)abs(m_LeftInlier[InlinerCount].x - B1) == pointselect[0])//最小点x
    334. 				{
    335. 					cout << j << "左图像选出的点1：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    336. 					cout << j << "右图像选出的点1：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    337.  
    338. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    339. 		            
    340. 					//垂足
    341. 					xll1 = (float)(B1);
    342. 					yll1 = (float)(m_LeftInlier[InlinerCount].y);
    343.  
    344. 					xrr1 = (float)(B2);
    345. 					yrr1 = (float)(m_RightInlier[InlinerCount].y);
    346. 				}
    347. 				if ((float)abs(m_LeftInlier[InlinerCount].x - B1)== pointselect[7])//最大点
    348. 				{
    349. 					cout << j << "左图像选出的点2：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    350. 					cout << j << "右图像选出的点2：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    351. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    352. 				    
    353. 					//垂足
    354. 					xll2 = (float)(B1);
    355. 					yll2 = (float)(m_LeftInlier[InlinerCount].y);
    356.  
    357. 					xrr2 = (float)(B2);
    358. 					yrr2 = (float)(m_RightInlier[InlinerCount].y);
    359. 				}
    360. 			}
    361. 			else if (vertical1 == true && vertical2 == false)//直线1垂直 直线二不垂直
    362. 			{
    363. 				if ((float)abs(m_LeftInlier[InlinerCount].x - B1) == pointselect[0])//最小点x
    364. 				{
    365. 					cout << j << "左图像选出的点1：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    366. 					cout << j << "右图像选出的点1：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    367.  
    368. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    369.  
    370. 					//垂足
    371. 					xll1 = (float)(B1);
    372. 					yll1 = (float)(m_LeftInlier[InlinerCount].y);
    373.  
    374. 					xrr1 = (float)(m_RightInlier[InlinerCount].x + K2 * m_RightInlier[InlinerCount].y - K2 * B2) / (K2 * K2 + 1);
    375. 					yrr1 = (float)(K2 * m_RightInlier[InlinerCount].x + K2 * K2 * m_RightInlier[InlinerCount].y + B2) / (K2 * K2 + 1);
    376. 				}
    377. 				if ((float)abs(m_LeftInlier[InlinerCount].x - B1) == pointselect[7])//最大点
    378. 				{
    379. 					cout << j << "左图像选出的点2：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    380. 					cout << j << "右图像选出的点2：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    381. 					line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    382.  
    383. 					//垂足
    384. 					xll2 = (float)(B1);
    385. 					yll2 = (float)(m_LeftInlier[InlinerCount].y);
    386.  
    387. 					xrr2 = (float)(m_RightInlier[InlinerCount].x + K2 * m_RightInlier[InlinerCount].y - K2 * B2) / (K2 * K2 + 1);
    388. 					yrr2 = (float)(K2 * m_RightInlier[InlinerCount].x + K2 * K2 * m_RightInlier[InlinerCount].y + B2) / (K2 * K2 + 1);
    389. 				}
    390. 			}
    391.  
    392. 			if (m_RightInlier[InlinerCount].x < inlier_minRx) inlier_minRx = m_RightInlier[InlinerCount].x;   //存储内点中右图最小横坐标
    393.  
    394. 			InlinerCount++;
    395.  
    396. 		}
    397. 		if (vertical1 == false && vertical2 == false)//直线1不垂直 直线2垂直
    398. 		{
    399. 			if ((float)abs((K1*m_LeftInlier[InlinerCount].x + B1 - m_LeftInlier[InlinerCount].y) / sqrt(K1 * K1 + 1 * 1)) == pointselect[0])//最小点
    400. 			{
    401. 				//匹配点
    402. 				cout << j << "左图像选出的点1：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    403. 				cout << j << "右图像选出的点1：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    404. 				line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    405.  
    406. 				//垂足
    407. 				xll1 = (float)(m_LeftInlier[InlinerCount].x + K1 * m_LeftInlier[InlinerCount].y - K1 * B1) / (K1 * K1 + 1);
    408. 				yll1 = (float)(K1 * m_LeftInlier[InlinerCount].x + K1 * K1 * m_LeftInlier[InlinerCount].y + B1) / (K1 * K1 + 1);
    409.  
    410. 				xrr1 = (float)(B2);
    411. 				yrr1 = (float)(m_RightInlier[InlinerCount].y);
    412.  
    413. 			}
    414. 			if ((float)abs((K1*m_LeftInlier[InlinerCount].x + B1 - m_LeftInlier[InlinerCount].y) / sqrt(K1 * K1 + 1 * 1)) == pointselect[7])//最大点
    415. 			{
    416. 				cout << j << "左图像选出的点2：" << m_LeftInlier[InlinerCount].x << " " << m_LeftInlier[InlinerCount].y << endl;
    417. 				cout << j << "右图像选出的点2：" << m_RightInlier[InlinerCount].x << " " << m_RightInlier[InlinerCount].y << endl;
    418. 				line(combine, Point2d(m_LeftInlier[InlinerCount].x, m_LeftInlier[InlinerCount].y), Point2d(4096 + m_RightInlier[InlinerCount].x, m_RightInlier[InlinerCount].y), Scalar(0, 255, 255), 2);
    419.  
    420. 				//垂足
    421. 				xll2 = (float)(m_LeftInlier[InlinerCount].x + K1 * m_LeftInlier[InlinerCount].y - K1 * B1) / (K1 * K1 + 1);
    422. 				yll2 = (float)(K1 * m_LeftInlier[InlinerCount].x + K1 * K1 * m_LeftInlier[InlinerCount].y + B1) / (K1 * K1 + 1);
    423.  
    424. 				xrr2 = (float)(B2);
    425. 				yrr2 = (float)(m_RightInlier[InlinerCount].y);
    426. 			}
    427. 		}
    428.  
    429. 	}
    430.  
    431. 	cout << "直线1垂足①:" << "x轴:" << xll1 << " " << "y轴:" << yll1 << endl;
    432. 	cout << "直线1垂足②:" << "x轴:" << xll2 << " " << "y轴:" << yll2 << endl;
    433. 	cout << "直线2垂足①:" << "x轴:" << xrr1 << " " << "y轴:" << yrr1 << endl;
    434. 	cout << "直线2垂足②:" << "x轴:" << xrr2 << " " << "y轴:" << yrr2 << endl;
    435.  
    436. 	imwrite("combine.bmp",combine);
    437. 	resize(combine, combine, Size(1024, 540));//显示改变大小
    438. 	imshow("输出想要的匹配点", combine);
    439. 	waitKey(0);
    440.  
    441. 	return 0;
    442. }

    可以得到如下的垂足

    说明结果正确. (代码写的太烂了,我自己都不想看了,不想改了)

  • 相关阅读:
    第十四届蓝桥杯大赛B组 JAVA 蜗牛 (递归剪枝）
    Halo-Theme-Hao文档：如何设置导航栏？
    OpenGL ES之深入解析PBO、UBO与TBO的功能和使用
    微信小程序开发：精细化处理人像动漫化调用之前的人像修复增强
    Meta因露骨AI图片陷入困境
    Hive insert插入数据与with子查询
    Android PreferenceScreen的使用和详解(设置页面)
    记一次vue3页面倒计时（定时器）切换页面问题
    Unity | unity&C++内存共享及中文乱码解决方式
    Java数组案例
  • 原文地址：https://blog.csdn.net/m0_47489229/article/details/127693065