OpenCV3历程（4）——寻找直线的十字交叉点

此篇文章转载自：https://www.cnblogs.com/jsxyhelu/p/10295373.html

首先上图：

这里的目标是寻找六条线段的交叉点，我一开始看到这个图片的时候觉得很简单，认为通过霍夫找线段然后求取交叉点就能实现，果不其然，我想太多了，经过对OpenCV里HoughLinesP（）函数的参数的各种调节，始终找不到所有的完整的线段，我觉得很大的原因可能是因为图片像素过高，后面我会继续摸索。

下面带来博客大神实现的方法（也存在一定的瑕疵，但效果已经很不错了）：

算法实践：

1、这样一个图像，单通道所以无法做HSV分解，必须考虑到光照影响，所以不能采用OSTU，经验告诉我，直接二值化能够得到较好效果。

 2、得到的结果，可能会有孤立点，需要通过形态学方法去除

• 腐蚀：腐蚀是一种消除边界点，使边界向内部收缩的过程。可以用来消除小且无意义的物体。
• 膨胀：膨胀是将与物体接触的所有背景点合并到该物体中，使边界向外部扩张的过程。可以用来填补物体中的空洞。
• 闭运算：闭运算用来填充物体内细小空洞、连接邻近物体、平滑其边界的同时并不明显改变其面积。基本上所有小到不能完整容纳结构元素的空隙或间隙，都会被闭运算消除（即连起来）。
• 开运算：用来背景中的消除小物体、在纤细点处分离物体、平滑较大物体的边界的同时并不明显改变其面积。所有小到不能容纳结构元素的物体都会被移除。

这里我们需要做的事“开运算”，根据观察，我们采用5*5的核：

得到的结果是奇异点全部消失，但是现有轮廓会有所衰弱

3、进一步执行细化，精确定位，也会出现细微偏差

4、那么，这个图像质量，我们如何建立特征提取模型了？ 对于这样一个点

 

4个象限，那么对于我们这些交点来说，肯定是有特征的，比如上图表示，对于这幅图像中的所有的点，可以区分为1-4个象限；就目前这4个象限中来看，每个象限都存在有数据的区域。但是经过编码发现，由于原图中有圆形等其他图像，干扰比较大，所以可以进一步增加约束为“寻找所有该点本身、其左边、右边、上边、下边都为255的点，由于这是一个比较明显的特征，所以我们可以直接编写代码去提取。

全部源码：

#include 
#include "opencv2\core.hpp"
#include "opencv2/shape.hpp"
#include "opencv2\opencv_modules.hpp"
#include 
#include 

using namespace cv;
using namespace std;

#define  DIRECTION_X 0
#define FALSE   0
#define TRUE    1

void thin(const Mat &src, Mat &dst, const int iterations = 100);
void projection2(Mat src, vector& vup, vector& vdown, int direction = DIRECTION_X, int gap = 10);



int main()
{
	Mat src = imread("./image/寻找激光的交叉点.bmp", 0);
	Mat srcClone = src.clone();
	Mat srcClone1 = src.clone();
	Mat srcBoard(src.size(), CV_8U, Scalar::all(0));
	//阈值处理
	threshold(src, src, 100, 255, THRESH_BINARY);
	//形态学去噪音
	Mat element = getStructuringElement(MORPH_RECT, Size(5, 5));
	//开运算，先腐蚀再膨胀，平滑物体轮廓，断开较窄的地方，清除细突
	morphologyEx(src, src, CV_MOP_OPEN, element);
	//二值图像细化处理
	thin(src, src);
	namedWindow("src", WINDOW_NORMAL);
	imshow("src", src);
	imwrite("srccc.jpg", src);
	//遍历图像,这里我在遍历的时候缩了一个像素
	vector vecPoints;
	for (int i = 1; i < src.rows - 1; i++) {
		for (int j = 1; j < src.cols - 1; j++) {
			if (src.at(i, j) == 255) //首先该像素要有数据
			{
				if (src.at(i - 1, j) == 255 && src.at(i + 1, j) == 255 && src.at(i, j - 1) == 255 && src.at(i, j + 1) == 255)
				{
					vecPoints.push_back(Point(j, i));
				}
			}

		}
	}
	//在底图上进行绘制
	cvtColor(srcClone, srcClone, COLOR_GRAY2BGR);
	cvtColor(srcClone1, srcClone1, COLOR_GRAY2BGR);
	//Point a;
	//a.x = vecPoints[0].x;
	//a.y = vecPoints[4].y;
	//circle(srcClone1, a, 10, Scalar(0, 0, 255), -1);
	//namedWindow("srcClone1", WINDOW_NORMAL);
	//imshow("srcClone1", srcClone1);
	//imwrite("srcClone1.jpg", srcClone1);
	for (int i = 0; i < vecPoints.size(); i++)
	{
		circle(srcClone, vecPoints[i], 10, Scalar(0, 0, 255), -1);
		circle(srcBoard, vecPoints[i], 1, Scalar(255), -1);
	}
	namedWindow("srcClone", WINDOW_NORMAL);
	imshow("srcClone", srcClone);
	imwrite("srcClone.jpg", srcClone);

	waitKey();
	return 0;
}

//将 DEPTH_8U型二值图像进行细化  经典的Zhang并行快速细化算法
void thin(const Mat &src, Mat &dst, const int iterations) {
	const int height = src.rows - 1;
	const int width = src.cols - 1;
	//拷贝一个数组给另一个数组
	if (src.data != dst.data)
		src.copyTo(dst);
	int n = 0, i = 0, j = 0;
	Mat tmpImg;
	uchar *pU, *pC, *pD;
	bool isFinished = FALSE;
	for (n = 0; n < iterations; n++) {
		dst.copyTo(tmpImg);
		isFinished = FALSE;   //一次 先行后列扫描 开始
		//扫描过程一 开始
		for (i = 1; i < height; i++) {
			pU = tmpImg.ptr(i - 1);
			pC = tmpImg.ptr(i);
			pD = tmpImg.ptr(i + 1);
			for (int j = 1; j < width; j++) {
				if (pC[j] > 0) {
					int ap = 0;
					int p2 = (pU[j] > 0);
					int p3 = (pU[j + 1] > 0);
					if (p2 == 0 && p3 == 1)
						ap++;
					int p4 = (pC[j + 1] > 0);
					if (p3 == 0 && p4 == 1)
						ap++;
					int p5 = (pD[j + 1] > 0);
					if (p4 == 0 && p5 == 1)
						ap++;
					int p6 = (pD[j] > 0);
					if (p5 == 0 && p6 == 1)
						ap++;
					int p7 = (pD[j - 1] > 0);
					if (p6 == 0 && p7 == 1)
						ap++;
					int p8 = (pC[j - 1] > 0);
					if (p7 == 0 && p8 == 1)
						ap++;
					int p9 = (pU[j - 1] > 0);
					if (p8 == 0 && p9 == 1)
						ap++;
					if (p9 == 0 && p2 == 1)
						ap++;
					if ((p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) > 1 && (p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) < 7) {
						if (ap == 1) {
							if ((p2*p4*p6 == 0) && (p4*p6*p8 == 0)) {
								dst.ptr(i)[j] = 0;
								isFinished = TRUE;
							}
						}
					}
				}

			} //扫描过程一 结束
			dst.copyTo(tmpImg);
			//扫描过程二 开始
			for (i = 1; i < height; i++) {
				pU = tmpImg.ptr(i - 1);
				pC = tmpImg.ptr(i);
				pD = tmpImg.ptr(i + 1);
				for (int j = 1; j < width; j++) {
					if (pC[j] > 0) {
						int ap = 0;
						int p2 = (pU[j] > 0);
						int p3 = (pU[j + 1] > 0);
						if (p2 == 0 && p3 == 1)
							ap++;
						int p4 = (pC[j + 1] > 0);
						if (p3 == 0 && p4 == 1)
							ap++;
						int p5 = (pD[j + 1] > 0);
						if (p4 == 0 && p5 == 1)
							ap++;
						int p6 = (pD[j] > 0);
						if (p5 == 0 && p6 == 1)
							ap++;
						int p7 = (pD[j - 1] > 0);
						if (p6 == 0 && p7 == 1)
							ap++;
						int p8 = (pC[j - 1] > 0);
						if (p7 == 0 && p8 == 1)
							ap++;
						int p9 = (pU[j - 1] > 0);
						if (p8 == 0 && p9 == 1)
							ap++;
						if (p9 == 0 && p2 == 1)
							ap++;
						if ((p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) > 1 && (p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) < 7) {
							if (ap == 1) {
								if ((p2*p4*p8 == 0) && (p2*p6*p8 == 0)) {
									dst.ptr(i)[j] = 0;
									isFinished = TRUE;
								}
							}
						}
					}
				}
			} //一次 先行后列扫描完成          
			//如果在扫描过程中没有删除点，则提前退出
			if (isFinished == FALSE)
				break;
		}
	}
}

得到以下结果：

可以看到，并没有得到全部的交叉点，我们需要对得到有限的点进行补全和排序，具体情况还是要具体分析，这里只做到这了！