提取接近竖直物体（粗定位）

由于项目的需要提取图像之中的一个接近于竖直的物体，一般的方法是进行图像分割，分割方式使用什么OTSU方式以及hsv方法等等。但是项目中使用的相机是黑白相机，会受到一定的限制。因此想到的是使用线条提取方式。线条提取方式之中最好的方法是使用canny算法，但是这里不能够将接近竖直特征进行提取，因此，此处使用了Prewitt算子进行提取，但是只用这个算法，轮廓提取不出来，就结合了一下canny算子。下面是我的思路，感觉实现过程比较麻烦，但是居然实现了[苦笑]！！！！

本次测试的案例是使用校门口的一个图片,图中存在很多的干扰,如下图所示

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
using namespace cv;
using namespace std;


void getPrewitt_oper(cv::Mat& getPrewitt_horizontal, cv::Mat& getPrewitt_vertical, cv::Mat& getPrewitt_Diagonal1, cv::Mat& getPrewitt_Diagonal2) {
	//水平方向
	getPrewitt_horizontal = (cv::Mat_<float>(3, 3) << -1, -1, -1, 0, 0, 0, 1, 1, 1);
	//垂直方向
	getPrewitt_vertical = (cv::Mat_<float>(3, 3) << -1, 0, 1, -1, 0, 1, -1, 0, 1);
	//对角135°
	getPrewitt_Diagonal1 = (cv::Mat_<float>(3, 3) << 0, 1, 1, -1, 0, 1, -1, -1, 0);
	//对角45°
	getPrewitt_Diagonal2 = (cv::Mat_<float>(3, 3) << -1, -1, 0, -1, 0, 1, 0, 1, 1);

	//逆时针反转180°得到卷积核
	cv::flip(getPrewitt_horizontal, getPrewitt_horizontal, -1);
	cv::flip(getPrewitt_vertical, getPrewitt_vertical, -1);
	cv::flip(getPrewitt_Diagonal1, getPrewitt_Diagonal1, -1);
	cv::flip(getPrewitt_Diagonal2, getPrewitt_Diagonal2, -1);
}

void edge_Prewitt(cv::Mat& src, cv::Mat& dst1, cv::Mat& dst2, cv::Mat& dst3, cv::Mat& dst4, cv::Mat& dst, int ddepth, double delta = 0, int borderType = cv::BORDER_DEFAULT) {
	//获取Prewitt算子
	cv::Mat getPrewitt_horizontal;
	cv::Mat getPrewitt_vertical;
	cv::Mat getPrewitt_Diagonal1;
	cv::Mat getPrewitt_Diagonal2;
	getPrewitt_oper(getPrewitt_horizontal, getPrewitt_vertical, getPrewitt_Diagonal1, getPrewitt_Diagonal2);

	//卷积得到水平方向边缘
	cv::filter2D(src, dst1, ddepth, getPrewitt_horizontal, cv::Point(-1, -1), delta, borderType);

	//卷积得到4垂直方向边缘
	cv::filter2D(src, dst2, ddepth, getPrewitt_vertical, cv::Point(-1, -1), delta, borderType);

	//卷积得到45°方向边缘
	cv::filter2D(src, dst3, ddepth, getPrewitt_Diagonal1, cv::Point(-1, -1), delta, borderType);

	//卷积得到135°方向边缘
	cv::filter2D(src, dst4, ddepth, getPrewitt_Diagonal2, cv::Point(-1, -1), delta, borderType);

	//边缘强度（近似）
	cv::convertScaleAbs(dst1, dst1); //求绝对值并转为无符号8位图
	cv::convertScaleAbs(dst2, dst2);

	cv::convertScaleAbs(dst3, dst3); //求绝对值并转为无符号8位图
	cv::convertScaleAbs(dst4, dst4);
	dst = dst1 + dst2;

}

//数组从大到小排序
void reserve(int x[], int n) {
	int i, j, temp;
	for (i = 0; i < n - 1; i++) {     //一共n个元素，则需要比较n-1次
		for (j = 0; j < n - 1 - i; j++) {     //每一个元素需要比较的次数
			if (x[i] < x[i + j + 1]) {
				temp = x[i];
				x[i] = x[i + j + 1];
				x[i + j + 1] = temp;
			}
		}
	}
}



int main()
{
	cv::Mat src = cv::imread("楼.jpg");
	if (src.empty()) {
		return -1;
	}
	cout << "??" << endl;
	if (src.channels() > 1) cv::cvtColor(src, src, CV_RGB2GRAY);
	cv::Mat dst, dst1, dst2, dst3, dst4, dst5;

	Mat src1 = cv::imread("楼.jpg");
	Mat src2 = cv::imread("楼.jpg");

	//medianBlur(src, src, 5);  //均值滤波
	GaussianBlur(src, src, Size(5, 5), 0); //高斯滤波
	cout << "??" << endl;

	//注意：要采用CV_32F，因为有些地方卷积后为负数，若用8位无符号，则会导致这些地方为0
	edge_Prewitt(src, dst1, dst2, dst3, dst4, dst, CV_32F);

	cv::namedWindow("垂直边缘", CV_WINDOW_NORMAL);
	imshow("垂直边缘", dst2);
	cout << "??" << endl;
	
	
	
	//获取结构
	cv::Mat element1 = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));

	Mat out1;
	//进行形态学开运算操作  
	morphologyEx(dst2, out1, MORPH_OPEN, element1);//形态学开运算
	cv::namedWindow("xingtai", CV_WINDOW_NORMAL);
	imshow("xingtai", out1);

	


	//第二次进行形态学操作
	edge_Prewitt(dst2, dst1, out1, dst3, dst4, dst, CV_32F);
	cv::namedWindow("垂直边缘1", CV_WINDOW_NORMAL);
	imshow("垂直边缘1", out1);
	cout << "??" << endl;

	morphologyEx(out1, out1, MORPH_OPEN, element1);//形态学开运算
	cv::namedWindow("xingtai1", CV_WINDOW_NORMAL);
	imshow("xingtai1", out1);


	//获取结构
	cv::Mat element2 = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(10, 10));

	Mat out2;
	//进行形态学闭运算操作  
	morphologyEx(out1, out2, MORPH_CLOSE, element2);//形态学开运算
	cv::namedWindow("xingtai2", CV_WINDOW_NORMAL);
	imshow("xingtai2", out2);
	imwrite("xingtai2.jpg", out2);

	/*
	//膨胀运算，将细小缝隙填补上,非必要
	Mat kernel = getStructuringElement(0, Size(3, 3));
	dilate(out2, dst2, kernel);
	cv::namedWindow("膨胀", CV_WINDOW_NORMAL);
	imshow("膨胀", dst2);
	*/
	
	cv::threshold(out2, dst2, 5, 255, cv::THRESH_BINARY);
	cv::namedWindow("二值化", CV_WINDOW_NORMAL);
	imshow("二值化", dst2);

	cv::threshold(dst2, dst2, 5, 255, cv::THRESH_BINARY_INV);
	cv::namedWindow("反二值化", CV_WINDOW_NORMAL);
	imshow("反二值化", dst2);

	
	//进行形态学闭运算操作  
	morphologyEx(dst2, out2, MORPH_CLOSE, element2);//形态学开运算
	cv::namedWindow("xingtai3", CV_WINDOW_NORMAL);
	imshow("xingtai3", out2);
	imwrite("xingtai3.jpg", out2);

	/*
	cv::threshold(dst2, dst2, 5, 255, cv::THRESH_BINARY);
	cv::namedWindow("反二值化", CV_WINDOW_NORMAL);
	imshow("反二值化", dst2);
	imwrite("反二值化.jpg", dst2);
	*/

	/*
	//膨胀运算，将细小缝隙填补上,非必要
    Mat kernel = getStructuringElement(0, Size(5, 5));
	dilate(out2, out2, kernel);
	cv::namedWindow("膨胀1", CV_WINDOW_NORMAL);
	imshow("膨胀1", out2);*/

	Canny(out2, dst2, 5, 10);
	cv::namedWindow("Canny", CV_WINDOW_NORMAL);
	imshow("Canny", dst2);
	imwrite("Canny.jpg", dst2);
	

	vector<Vec4i> lines;
	HoughLinesP(dst2, lines, 1, CV_PI / 180, 50, 200, 30);
	int Length[100] = {0};//存放直线长度
	for (size_t i = 0; i < lines.size(); i++)
	{
		Vec4i I = lines[i];
		double x1 = I[0];
		double y1 = I[1];
		double x2 = I[2];
		double y2 = I[3];

		//筛选满足条件的点
		if (abs(x1 - x2) + abs(y1 - y2) > 50)
		{
			Length[i] = sqrt( (x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2));
			//将满足条件的点画出
			line(src1, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);

			cout << " " << "(" << x1 << "," << y1 << ")" << " " << "(" << x2 << "," << y2 << ")" << endl;
			//line(canny, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);
		}
	}

	Mat imgShow;
	imgShow = src1;
	resize(imgShow, imgShow, Size(imgShow.cols / 4, imgShow.rows / 4));
	imshow("imgShow", imgShow);
	imwrite("shuchu.png", src1);


	reserve(Length, 100);
	for (int i = 0; i < 100; i++) {
		cout << "长度"<<Length[i] << endl;   //输出排序后的数组元素
	}

	for (size_t i = 0; i < lines.size(); i++)
	{
		Vec4i I = lines[i];
		double x1 = I[0];
		double y1 = I[1];
		double x2 = I[2];
		double y2 = I[3];
		cout << "sdjk" << endl;
		cout << int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) << endl;
		//筛选满足条件的点
		if ((int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) == Length[0] ) || (int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) == Length[1]))
		{
			
			//将满足条件的点画出
			line(src2, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);

			cout << "djfkljsa " << "(" << x1 << "," << y1 << ")" << " " << "(" << x2 << "," << y2 << ")" << endl;
			//line(canny, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);
		}
	}
	
	imgShow = src2;
	resize(imgShow, imgShow, Size(imgShow.cols / 4, imgShow.rows / 4));
	imshow("imgShow2", imgShow);
	imwrite("shuchu2.png", src2);





	waitKey(0);
	return 0;
}

调试过程:本次在进行调试过程之中进行了两次垂直检测迭代,进一步去排除水平线的干扰.使用形态学操作去除图片之中的空洞等等.

第一次进行垂直检测,注意这个地方只能够用特定的算子进行垂直检测,别的算子没有这个效果. 

为了减少图片之中白色空洞的干扰,使用开操作.

重复上述操作,进一步排除水平线的干扰.

接下来是进行闭操作,将图中的白色线条尽可能连在一起,上图之中的楼左侧的线有一些断开了.

闭操作的缺陷是会产生小白点点.如下二值化过程

再进行一次反二值化,因为我不会用别的算子结合霍夫直线检测检测出来直线,只能转回去进行操作. 

形态学操作,去除白点

 canny一下检测出来轮廓

显示全部直线

 直线提取，我的方式是提取最长的两段直线。

 在上述操作完成之后，得到了物体的粗定位直线。

但是上面的算法还是存在相应的问题，换了一个别的图像可能就检测的不准。发现问题就是出在了二值化的过程。

为了修正上方的算法的失败，使用提取外部轮廓的方式进行求取，将代码改了改。
 

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
using namespace cv;
using namespace std;


void getPrewitt_oper(cv::Mat& getPrewitt_horizontal, cv::Mat& getPrewitt_vertical, cv::Mat& getPrewitt_Diagonal1, cv::Mat& getPrewitt_Diagonal2) {
	//水平方向
	getPrewitt_horizontal = (cv::Mat_<float>(3, 3) << -1, -1, -1, 0, 0, 0, 1, 1, 1);
	//垂直方向
	getPrewitt_vertical = (cv::Mat_<float>(3, 3) << -1, 0, 1, -1, 0, 1, -1, 0, 1);
	//对角135°
	getPrewitt_Diagonal1 = (cv::Mat_<float>(3, 3) << 0, 1, 1, -1, 0, 1, -1, -1, 0);
	//对角45°
	getPrewitt_Diagonal2 = (cv::Mat_<float>(3, 3) << -1, -1, 0, -1, 0, 1, 0, 1, 1);

	//逆时针反转180°得到卷积核
	cv::flip(getPrewitt_horizontal, getPrewitt_horizontal, -1);
	cv::flip(getPrewitt_vertical, getPrewitt_vertical, -1);
	cv::flip(getPrewitt_Diagonal1, getPrewitt_Diagonal1, -1);
	cv::flip(getPrewitt_Diagonal2, getPrewitt_Diagonal2, -1);
}

void edge_Prewitt(cv::Mat& src, cv::Mat& dst1, cv::Mat& dst2, cv::Mat& dst3, cv::Mat& dst4, cv::Mat& dst, int ddepth, double delta = 0, int borderType = cv::BORDER_DEFAULT) {
	//获取Prewitt算子
	cv::Mat getPrewitt_horizontal;
	cv::Mat getPrewitt_vertical;
	cv::Mat getPrewitt_Diagonal1;
	cv::Mat getPrewitt_Diagonal2;
	getPrewitt_oper(getPrewitt_horizontal, getPrewitt_vertical, getPrewitt_Diagonal1, getPrewitt_Diagonal2);

	//卷积得到水平方向边缘
	cv::filter2D(src, dst1, ddepth, getPrewitt_horizontal, cv::Point(-1, -1), delta, borderType);

	//卷积得到4垂直方向边缘
	cv::filter2D(src, dst2, ddepth, getPrewitt_vertical, cv::Point(-1, -1), delta, borderType);

	//卷积得到45°方向边缘
	cv::filter2D(src, dst3, ddepth, getPrewitt_Diagonal1, cv::Point(-1, -1), delta, borderType);

	//卷积得到135°方向边缘
	cv::filter2D(src, dst4, ddepth, getPrewitt_Diagonal2, cv::Point(-1, -1), delta, borderType);

	//边缘强度（近似）
	cv::convertScaleAbs(dst1, dst1); //求绝对值并转为无符号8位图
	cv::convertScaleAbs(dst2, dst2);

	cv::convertScaleAbs(dst3, dst3); //求绝对值并转为无符号8位图
	cv::convertScaleAbs(dst4, dst4);
	dst = dst1 + dst2;

}

//数组从大到小排序
void reserve(int x[], int n) {
	int i, j, temp;
	for (i = 0; i < n - 1; i++) {     //一共n个元素，则需要比较n-1次
		for (j = 0; j < n - 1 - i; j++) {     //每一个元素需要比较的次数
			if (x[i] < x[i + j + 1]) {
				temp = x[i];
				x[i] = x[i + j + 1];
				x[i + j + 1] = temp;
			}
		}
	}
}



int main()
{
	cv::Mat src = cv::imread("楼.jpg");
	if (src.empty()) {
		return -1;
	}
	cout << "??" << endl;
	if (src.channels() > 1) cv::cvtColor(src, src, CV_RGB2GRAY);
	cv::Mat dst, dst1, dst2, dst3, dst4, dst5;

	Mat src1 = cv::imread("楼.jpg");
	Mat src2 = cv::imread("楼.jpg");

	//medianBlur(src, src, 5);  //均值滤波
	GaussianBlur(src, src, Size(5, 5), 0); //高斯滤波
	cout << "??" << endl;

	//注意：要采用CV_32F，因为有些地方卷积后为负数，若用8位无符号，则会导致这些地方为0
	edge_Prewitt(src, dst1, dst2, dst3, dst4, dst, CV_32F);

	cv::namedWindow("垂直边缘", CV_WINDOW_NORMAL);
	imshow("垂直边缘", dst2);
	cout << "??" << endl;

	

	/*
	Mat shdjk;
	cv::threshold(dst2, shdjk, 25, 255, cv::THRESH_BINARY);
	cv::namedWindow("二值化1212", CV_WINDOW_NORMAL);
	imshow("二值化1212", shdjk);
	*/

	//获取结构
	cv::Mat element1 = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));

	Mat out1;
	//进行形态学开运算操作  
	morphologyEx(dst2, out1, MORPH_OPEN, element1);//形态学开运算
	cv::namedWindow("xingtai", CV_WINDOW_NORMAL);
	imshow("xingtai", out1);


	Mat out2;
	//第二次进行形态学操作
	edge_Prewitt(out1, dst1, out1, dst3, dst4, dst, CV_32F);
	cv::namedWindow("垂直边缘1", CV_WINDOW_NORMAL);
	imshow("垂直边缘1", out1);
	cout << "??" << endl;


	/*
	morphologyEx(out1, out1, MORPH_OPEN, element1);//形态学开运算
	cv::namedWindow("xingtai1", CV_WINDOW_NORMAL);
	imshow("xingtai1", out1);

	//获取结构
	cv::Mat element2 = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(10, 10));

	
	//进行形态学闭运算操作  
	morphologyEx(out1, out2, MORPH_CLOSE, element2);//形态学闭合运算
	cv::namedWindow("xingtai2", CV_WINDOW_NORMAL);
	imshow("xingtai2", out2);
	imwrite("xingtai2.jpg", out2);
	
	waitKey(0);
	*/
	std::vector<std::vector<cv::Point>> contours;
	std::vector<cv::Vec4i> hierarchy;
	findContours(out1, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
	double maxArea = 0;
	int index = 0;
	vector<cv::Point> maxContour;
	for (size_t i = 0; i < contours.size(); i++)
	{
		double area = cv::contourArea(contours[i]);
		if (area > maxArea)
		{
			maxArea = area;
			maxContour = contours[i];
			index = i;
		}
	}
	drawContours(src1, contours, index, Scalar(255));    // 参数
	cv::namedWindow("test", CV_WINDOW_NORMAL);
	imshow("test", src1);
	waitKey(0);
	/*
	Mat shdjk;
	cv::threshold(out1, shdjk, 10, 255, cv::THRESH_BINARY);
	cv::namedWindow("二值化1212", CV_WINDOW_NORMAL);
	imshow("二值化1212", shdjk);

	std::vector<std::vector<cv::Point>> contours;
	std::vector<cv::Vec4i> hierarchy;
	cv::findContours(shdjk, contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);  //只找最外层轮廓


	std::vector<std::vector<cv::Point>> approxCurves(contours.size());
	for (int i = 0; i < contours.size(); ++i) {  //绘制逼近后的轮廓
		double epsilon = 0.1 * cv::arcLength(contours[i], true);
		cv::approxPolyDP(contours[i], approxCurves[i], epsilon, true);

		cv::drawContours(src1, approxCurves, i, cv::Scalar(0, 255, 0), 2);
	}
	cv::namedWindow("success", CV_WINDOW_NORMAL);
	imshow("success", src1);

	cv::waitKey();

	*/

	

	

	//
	/*
	Mat dhfjua;
	cv::threshold(out2, dhfjua, 15, 255, cv::THRESH_BINARY);
	cv::namedWindow("二值化000", CV_WINDOW_NORMAL);
	imshow("二值化000", dhfjua);
	*/
	/*
	//膨胀运算，将细小缝隙填补上,非必要
	Mat kernel = getStructuringElement(0, Size(3, 3));
	dilate(out2, dst2, kernel);
	cv::namedWindow("膨胀", CV_WINDOW_NORMAL);
	imshow("膨胀", dst2);
	*/
	/*0
	cv::threshold(out2, dst2, 5, 255, cv::THRESH_BINARY);
	cv::namedWindow("二值化", CV_WINDOW_NORMAL);
	imshow("二值化", dst2);

	cv::threshold(dst2, dst2, 5, 255, cv::THRESH_BINARY_INV);
	cv::namedWindow("反二值化", CV_WINDOW_NORMAL);
	imshow("反二值化", dst2);
	*/
	/*
	Mat out3;
	//进行形态学闭运算操作  
	morphologyEx(dst2, out3, MORPH_CLOSE, element2);//形态学开运算
	cv::namedWindow("xingtai3", CV_WINDOW_NORMAL);
	imshow("xingtai3", out3);
	imwrite("xingtai3.jpg", out3);
	*/

	waitKey(0);
	vector<Vec4i> lines;
	HoughLinesP(src1, lines, 1, CV_PI / 180, 100, 400, 30);
	int Length[1000] = { 0 };//存放直线长度
	for (size_t i = 0; i < lines.size(); i++)
	{
		Vec4i I = lines[i];
		double x1 = I[0];
		double y1 = I[1];
		double x2 = I[2];
		double y2 = I[3];

		//筛选满足条件的点
		if (abs(x1 - x2) + abs(y1 - y2) > 50)
		{
			Length[i] = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2));
			//将满足条件的点画出
			line(src1, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);

			cout << " " << "(" << x1 << "," << y1 << ")" << " " << "(" << x2 << "," << y2 << ")" << endl;
			//line(canny, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);
		}
	}

	

	Mat imgShow;
	imgShow = src1;
	resize(imgShow, imgShow, Size(imgShow.cols / 4, imgShow.rows / 4));
	imshow("imgShow", imgShow);
	imwrite("shuchu.png", src1);


	reserve(Length, 1000);
	for (int i = 0; i < 1000; i++) {
		cout << "长度" << Length[i] << endl;   //输出排序后的数组元素
	}

	for (size_t i = 0; i < lines.size(); i++)
	{
		Vec4i I = lines[i];
		double x1 = I[0];
		double y1 = I[1];
		double x2 = I[2];
		double y2 = I[3];
		cout << "sdjk" << endl;
		cout << int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) << endl;
		//筛选满足条件的点
		if ((int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) == Length[0]) || (int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) == Length[1]))
		{

			//将满足条件的点画出
			line(src2, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);

			cout << "djfkljsa " << "(" << x1 << "," << y1 << ")" << " " << "(" << x2 << "," << y2 << ")" << endl;
			//line(canny, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);
		}
	}

	imgShow = src2;
	resize(imgShow, imgShow, Size(imgShow.cols / 4, imgShow.rows / 4));
	imshow("imgShow2", imgShow);
	imwrite("shuchu2.png", src2);





	waitKey(0);
	return 0;
}

效果还是不好，问题就是出在了相应的一个二值化的过程，因此，想到使用区域增长算法改进

#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>
#include <stack>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>


using namespace std;
using namespace cv;


//------------------------------【两步法新改进版】----------------------------------------------
// 对二值图像进行连通区域标记,从1开始标号
void  Two_PassNew(const Mat &bwImg, Mat &labImg)
{
	assert(bwImg.type() == CV_8UC1);
	labImg.create(bwImg.size(), CV_32SC1);   //bwImg.convertTo( labImg, CV_32SC1 );
	labImg = Scalar(0);
	labImg.setTo(Scalar(1), bwImg);
	assert(labImg.isContinuous());
	const int Rows = bwImg.rows - 1, Cols = bwImg.cols - 1;
	int label = 1;
	vector<int> labelSet;
	labelSet.push_back(0);
	labelSet.push_back(1);
	//the first pass
	int *data_prev = (int*)labImg.data;   //0-th row : int* data_prev = labImg.ptr<int>(i-1);
	int *data_cur = (int*)(labImg.data + labImg.step); //1-st row : int* data_cur = labImg.ptr<int>(i);
	for (int i = 1; i < Rows; i++)
	{
		data_cur++;
		data_prev++;
		for (int j = 1; j < Cols; j++, data_cur++, data_prev++)
		{
			if (*data_cur != 1)
				continue;
			int left = *(data_cur - 1);
			int up = *data_prev;
			int neighborLabels[2];
			int cnt = 0;
			if (left > 1)
				neighborLabels[cnt++] = left;
			if (up > 1)
				neighborLabels[cnt++] = up;
			if (!cnt)
			{
				labelSet.push_back(++label);
				labelSet[label] = label;
				*data_cur = label;
				continue;
			}
			int smallestLabel = neighborLabels[0];
			if (cnt == 2 && neighborLabels[1] < smallestLabel)
				smallestLabel = neighborLabels[1];
			*data_cur = smallestLabel;
			// 保存最小等价表
			for (int k = 0; k < cnt; k++)
			{
				int tempLabel = neighborLabels[k];
				int& oldSmallestLabel = labelSet[tempLabel];  //这里的&不是取地址符号,而是引用符号
				if (oldSmallestLabel > smallestLabel)
				{
					labelSet[oldSmallestLabel] = smallestLabel;
					oldSmallestLabel = smallestLabel;
				}
				else if (oldSmallestLabel < smallestLabel)
					labelSet[smallestLabel] = oldSmallestLabel;
			}
		}
		data_cur++;
		data_prev++;
	}
	//更新等价队列表,将最小标号给重复区域
	for (size_t i = 2; i < labelSet.size(); i++)
	{
		int curLabel = labelSet[i];
		int prelabel = labelSet[curLabel];
		while (prelabel != curLabel)
		{
			curLabel = prelabel;
			prelabel = labelSet[prelabel];
		}
		labelSet[i] = curLabel;
	}
	//second pass
	data_cur = (int*)labImg.data;
	for (int i = 0; i < Rows; i++)
	{
		for (int j = 0; j < bwImg.cols - 1; j++, data_cur++)
			*data_cur = labelSet[*data_cur];
		data_cur++;
	}
}

//-------------------------------【老版两步法】-------------------------------------------
void Two_PassOld(const cv::Mat& _binImg, cv::Mat& _lableImg)
{
	//connected component analysis (4-component)
	//use two-pass algorithm
	//1. first pass: label each foreground pixel with a label
	//2. second pass: visit each labeled pixel and merge neighbor label
	//
	//foreground pixel: _binImg(x,y) = 1
	//background pixel: _binImg(x,y) = 0

	if (_binImg.empty() || _binImg.type() != CV_8UC1)
	{
		return;
	}

	// 1. first pass
	_lableImg.release();
	_binImg.convertTo(_lableImg, CV_32SC1);

	int label = 1;  // start by 2
	std::vector<int> labelSet;
	labelSet.push_back(0);   //background: 0
	labelSet.push_back(1);   //foreground: 1

	int rows = _binImg.rows - 1;
	int cols = _binImg.cols - 1;
	for (int i = 1; i < rows; i++)
	{
		int* data_preRow = _lableImg.ptr<int>(i - 1);
		int* data_curRow = _lableImg.ptr<int>(i);
		for (int j = 1; j < cols; j++)
		{
			if (data_curRow[j] == 1)
			{
				std::vector<int> neighborLabels;
				neighborLabels.reserve(2); //reserve(n)  预分配n个元素的存储空间
				int leftPixel = data_curRow[j - 1];
				int upPixel = data_preRow[j];
				if (leftPixel > 1)
				{
					neighborLabels.push_back(leftPixel);
				}
				if (upPixel > 1)
				{
					neighborLabels.push_back(upPixel);
				}
				if (neighborLabels.empty())
				{
					labelSet.push_back(++label);   //assign to a new label
					data_curRow[j] = label;
					labelSet[label] = label;
				}
				else
				{
					std::sort(neighborLabels.begin(), neighborLabels.end());
					int smallestLabel = neighborLabels[0];
					data_curRow[j] = smallestLabel;

					//save equivalence
					for (size_t k = 1; k < neighborLabels.size(); k++)
					{
						int tempLabel = neighborLabels[k];
						int& oldSmallestLabel = labelSet[tempLabel];
						if (oldSmallestLabel > smallestLabel)
						{
							labelSet[oldSmallestLabel] = smallestLabel;
							oldSmallestLabel = smallestLabel;
						}
						else if (oldSmallestLabel < smallestLabel)
						{
							labelSet[smallestLabel] = oldSmallestLabel;
						}
					}
				}

			}
		}
	}
	//update equivalent labels
	//assigned with the smallest label in each equivalent label set
	for (size_t i = 2; i < labelSet.size(); i++)
	{
		int curLabel = labelSet[i];
		int prelabel = labelSet[curLabel];
		while (prelabel != curLabel)
		{
			curLabel = prelabel;
			prelabel = labelSet[prelabel];
		}
		labelSet[i] = curLabel;
	}

	//2. second pass
	for (int i = 0; i < rows; i++)
	{
		int *data = _lableImg.ptr<int>(i);
		for (int j = 0; j < cols; j++)
		{
			int& pixelLabel = data[j];
			pixelLabel = labelSet[pixelLabel];
		}
	}
}


//---------------------------------【种子填充法老版】-------------------------------
void SeedFillOld(const cv::Mat& binImg, cv::Mat& lableImg)   //种子填充法
{
	// 4邻接方法


	if (binImg.empty() ||
		binImg.type() != CV_8UC1)
	{
		return;
	}

	lableImg.release();
	binImg.convertTo(lableImg, CV_32SC1);

	int label = 1;

	int rows = binImg.rows - 1;
	int cols = binImg.cols - 1;
	for (int i = 1; i < rows - 1; i++)
	{
		int* data = lableImg.ptr<int>(i);
		for (int j = 1; j < cols - 1; j++)
		{
			if (data[j] == 1)
			{
				std::stack<std::pair<int, int>> neighborPixels;
				neighborPixels.push(std::pair<int, int>(i, j));     // 像素位置: <i,j>
				++label;  // 没有重复的团，开始新的标签
				while (!neighborPixels.empty())
				{
					std::pair<int, int> curPixel = neighborPixels.top(); //如果与上一行中一个团有重合区域，则将上一行的那个团的标号赋给它
					int curX = curPixel.first;
					int curY = curPixel.second;
					lableImg.at<int>(curX, curY) = label;

					neighborPixels.pop();

					if (lableImg.at<int>(curX, curY - 1) == 1)
					{//左边
						neighborPixels.push(std::pair<int, int>(curX, curY - 1));
					}
					if (lableImg.at<int>(curX, curY + 1) == 1)
					{// 右边
						neighborPixels.push(std::pair<int, int>(curX, curY + 1));
					}
					if (lableImg.at<int>(curX - 1, curY) == 1)
					{// 上边
						neighborPixels.push(std::pair<int, int>(curX - 1, curY));
					}
					if (lableImg.at<int>(curX + 1, curY) == 1)
					{// 下边
						neighborPixels.push(std::pair<int, int>(curX + 1, curY));
					}
				}
			}
		}
	}

}




//-------------------------------------------【种子填充法新版】---------------------------
void SeedFillNew(const cv::Mat& _binImg, cv::Mat& _lableImg)
{
	// connected component analysis(4-component)
	// use seed filling algorithm
	// 1. begin with a forgeground pixel and push its forground neighbors into a stack;
	// 2. pop the pop pixel on the stack and label it with the same label until the stack is empty
	// 
	//  forground pixel: _binImg(x,y)=1
	//  background pixel: _binImg(x,y) = 0


	if (_binImg.empty() ||
		_binImg.type() != CV_8UC1)
	{
		return;
	}

	_lableImg.release();
	_binImg.convertTo(_lableImg, CV_32SC1);

	int label = 0; //start by 1

	int rows = _binImg.rows;
	int cols = _binImg.cols;

	Mat mask(rows, cols, CV_8UC1);
	mask.setTo(0);
	int *lableptr;
	for (int i = 0; i < rows; i++)
	{
		int* data = _lableImg.ptr<int>(i);
		uchar *masKptr = mask.ptr<uchar>(i);
		for (int j = 0; j < cols; j++)
		{
			if (data[j] == 255 && mask.at<uchar>(i, j) != 1)
			{
				mask.at<uchar>(i, j) = 1;
				std::stack<std::pair<int, int>> neighborPixels;
				neighborPixels.push(std::pair<int, int>(i, j)); // pixel position: <i,j>
				++label; //begin with a new label
				while (!neighborPixels.empty())
				{
					//get the top pixel on the stack and label it with the same label
					std::pair<int, int> curPixel = neighborPixels.top();
					int curY = curPixel.first;
					int curX = curPixel.second;
					_lableImg.at<int>(curY, curX) = label;

					//pop the top pixel
					neighborPixels.pop();

					//push the 4-neighbors(foreground pixels)

					if (curX - 1 >= 0)
					{
						if (_lableImg.at<int>(curY, curX - 1) == 255 && mask.at<uchar>(curY, curX - 1) != 1) //leftpixel
						{
							neighborPixels.push(std::pair<int, int>(curY, curX - 1));
							mask.at<uchar>(curY, curX - 1) = 1;
						}
					}
					if (curX + 1 <= cols - 1)
					{
						if (_lableImg.at<int>(curY, curX + 1) == 255 && mask.at<uchar>(curY, curX + 1) != 1)
							// right pixel
						{
							neighborPixels.push(std::pair<int, int>(curY, curX + 1));
							mask.at<uchar>(curY, curX + 1) = 1;
						}
					}
					if (curY - 1 >= 0)
					{
						if (_lableImg.at<int>(curY - 1, curX) == 255 && mask.at<uchar>(curY - 1, curX) != 1)
							// up pixel
						{
							neighborPixels.push(std::pair<int, int>(curY - 1, curX));
							mask.at<uchar>(curY - 1, curX) = 1;
						}
					}
					if (curY + 1 <= rows - 1)
					{
						if (_lableImg.at<int>(curY + 1, curX) == 255 && mask.at<uchar>(curY + 1, curX) != 1)
							//down pixel
						{
							neighborPixels.push(std::pair<int, int>(curY + 1, curX));
							mask.at<uchar>(curY + 1, curX) = 1;
						}
					}
				}
			}
		}
	}
}


//---------------------------------【颜色标记程序】-----------------------------------
//彩色显示
cv::Scalar GetRandomColor()
{
	uchar r = 255 * (rand() / (1.0 + RAND_MAX));
	uchar g = 255 * (rand() / (1.0 + RAND_MAX));
	uchar b = 255 * (rand() / (1.0 + RAND_MAX));
	return cv::Scalar(b, g, r);
}


void LabelColor(const cv::Mat& labelImg, cv::Mat& colorLabelImg)
{
	int num = 0;
	if (labelImg.empty() ||
		labelImg.type() != CV_32SC1)
	{
		return;
	}

	std::map<int, cv::Scalar> colors;

	int rows = labelImg.rows;
	int cols = labelImg.cols;

	colorLabelImg.release();
	colorLabelImg.create(rows, cols, CV_8UC3);
	colorLabelImg = cv::Scalar::all(0);

	for (int i = 0; i < rows; i++)
	{
		const int* data_src = (int*)labelImg.ptr<int>(i);
		uchar* data_dst = colorLabelImg.ptr<uchar>(i);
		for (int j = 0; j < cols; j++)
		{
			int pixelValue = data_src[j];
			if (pixelValue > 1)
			{
				if (colors.count(pixelValue) <= 0)
				{
					colors[pixelValue] = GetRandomColor();
					num++;
				}

				cv::Scalar color = colors[pixelValue];
				*data_dst++ = color[0];
				*data_dst++ = color[1];
				*data_dst++ = color[2];
			}
			else
			{
				data_dst++;
				data_dst++;
				data_dst++;
			}
		}
	}
	printf("color num : %d \n", num);
}

//------------------------------------------【测试主程序】-------------------------------------
int main()
{

	cv::Mat binImage = cv::imread("sda.jpg", 0);
	//cv::threshold(binImage, binImage, 50, 1, CV_THRESH_BINARY);
	cv::Mat labelImg;
	double time;
	time = getTickCount();
	
	SeedFillNew(binImage, labelImg);
	time = 1000 * ((double)getTickCount() - time) / getTickFrequency();
	cout << std::fixed << time << "ms" << endl;
	//彩色显示
	/*
	cv::Mat colorLabelImg;
	LabelColor(labelImg, colorLabelImg);
	cv::imshow("colorImg", colorLabelImg);
	*/
	//灰度显示
	cv::Mat grayImg;
	labelImg *= 10;
	labelImg.convertTo(grayImg, CV_8UC1);
	cv::imshow("labelImg", grayImg);
	double minval, maxval;
	minMaxLoc(labelImg, &minval, &maxval);
	cout << "minval" << minval << endl;
	cout << "maxval" << maxval << endl;
	cv::waitKey(0);
	return 0;
}

终于知道是啥原因了，我在进行Prewitt算子对边缘进行粗定位检测过后，没有进行去噪处理，一定要把图像转换为二值图像，就方便多了。并且还要记住，霍夫检测的直线像素是255白线才可以，经过长时间的试错终于解决了。输入原图像如下所示，我这里使用的去噪对比了四种，但是下面这种是最好的。Opencv 非局部降噪_51CTO博客_opencv降噪Opencv 非局部降噪，opencv自带的非局部降噪算法：CV_EXPORTS_WvoidfastNlMeansDenoising(InputArraysrc,OutputArraydst,floath=3,inttemplateWindowSize=7,intsearchWindowSize=21);h是过滤强度，templateWindowSize是分块大小，searchWindowSize是搜索区域大小。应用实例intmain(){MatI..https://blog.51cto.com/u_15458280/4843576

#include<opencv2/opencv.hpp>
#include<iostream>
using namespace std;
using namespace cv;

//数组从大到小排序
void reserve(int x[], int n) {
	int i, j, temp;
	for (i = 0; i < n - 1; i++) {     //一共n个元素，则需要比较n-1次
		for (j = 0; j < n - 1 - i; j++) {     //每一个元素需要比较的次数
			if (x[i] < x[i + j + 1]) {
				temp = x[i];
				x[i] = x[i + j + 1];
				x[i + j + 1] = temp;
			}
		}
	}
}

void add_salt_pepper_noise(Mat &image) {
	RNG rng(12345);
	int h = image.rows;
	int w = image.cols;
	int nums = 10000;
	for (int i = 0; i < nums; i++) {
		int x = rng.uniform(0, w);
		int y = rng.uniform(0, h);
		if (i % 2 == 1) {
			image.at<Vec3b>(y, x) = Vec3b(255, 255, 255);
		}
		else {
			image.at<Vec3b>(y, x) = Vec3b(0, 0, 0);
		}
	}
	imshow("salt pepper", image);
}

void gaussian_noise(Mat &image) {
	Mat noise = Mat::zeros(image.size(), image.type());
	randn(noise, (15, 15, 15), (30, 30, 30));
	Mat dst;
	add(image, noise, dst);
	imshow("gaussian noise", dst);
	dst.copyTo(image);
}

Mat convertTo3Channels(const Mat& binImg)
{
	Mat three_channel = Mat::zeros(binImg.rows, binImg.cols, CV_8UC3);
	vector<Mat> channels;
	for (int i = 0; i < 3; i++)
	{
		channels.push_back(binImg);
	}
	merge(channels, three_channel);
	return three_channel;
}

int main(int argc, char*argv[])
{
	//加载图像
	Mat img, gray_image, dst;
	img = imread("垂直边缘.jpg");
	 Mat img1 = imread("垂直边缘.jpg");
	//判断图像是否导入成功
	if (img.empty())
	{
		cout << "加载失败" << endl;
		return -1;
	}
	//显示图像
	namedWindow("original image", WINDOW_AUTOSIZE);
	imshow("original image", img);
	//转换灰度图像
	cvtColor(img, gray_image, COLOR_BGR2GRAY);
	//获取灰度图像宽度和高度
	int width = gray_image.cols;
	int height = gray_image.rows;
	//遍历像素值(单通道)
	for (int row = 0; row < height; row++)
	{
		for (int col = 0; col < width; col++)
		{
			int gray = gray_image.at<uchar>(row, col);
			gray_image.at<uchar>(row, col) = 255 - gray;	//图像取反
		};
	};
	namedWindow("inv_gray_image", WINDOW_AUTOSIZE);
	imshow("inv_gray_image", gray_image);


	Mat sh;
	
	fastNlMeansDenoising(gray_image, sh, 21, 7, 21);
	namedWindow("inv_gray_image1", WINDOW_AUTOSIZE);
	imshow("inv_gray_image1", sh);
	
	
	waitKey(50);

	
	//Mat s;
	//获取灰度图像宽度和高度
	 width = sh.cols;
	 height = sh.rows;
	//遍历像素值(单通道)
	for (int row = 0; row < height; row++)
	{
		for (int col = 0; col < width; col++)
		{
			int gray = sh.at<uchar>(row, col);
			sh.at<uchar>(row, col) = 255 - gray;	//图像取反
		};
	};
	namedWindow("inv_gray_image2", WINDOW_AUTOSIZE);
	imshow("inv_gray_image2", sh);

	
	cv::threshold(sh, sh, 50, 255, cv::THRESH_BINARY);
	cv::namedWindow("二值化", CV_WINDOW_NORMAL);
	imshow("二值化", sh);

	vector<Vec4i> lines;
	HoughLinesP(sh, lines, 1, CV_PI / 180, 50,100, 5);
	int Length[100] = { 0 };//存放直线长度
	for (size_t i = 0; i < lines.size(); i++)
	{
		Vec4i I = lines[i];
		double x1 = I[0];
		double y1 = I[1];
		double x2 = I[2];
		double y2 = I[3];

		//筛选满足条件的点
		if (abs(x1 - x2) + abs(y1 - y2) > 50)
		{
			Length[i] = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2));
			//将满足条件的点画出
			line(img, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);

			cout << " " << "(" << x1 << "," << y1 << ")" << " " << "(" << x2 << "," << y2 << ")" << endl;
			//line(canny, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);
		}
	}

	Mat imgShow;
	imgShow = img;
	resize(imgShow, imgShow, Size(imgShow.cols / 4, imgShow.rows / 4));
	imshow("imgShow", imgShow);
	imwrite("shuchu.png", imgShow);


	reserve(Length, 100);
	for (int i = 0; i < 100; i++) {
		cout << "长度" << Length[i] << endl;   //输出排序后的数组元素
	}

	for (size_t i = 0; i < lines.size(); i++)
	{
		Vec4i I = lines[i];
		double x1 = I[0];
		double y1 = I[1];
		double x2 = I[2];
		double y2 = I[3];
		cout << "sdjk" << endl;
		cout << int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) << endl;
		//筛选满足条件的点
		if ((int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) == Length[0]) || (int(sqrt((x1 - x2)*(x1 - x2) + (y1 - y2) * (y1 - y2))) == Length[1]))
		{

			//将满足条件的点画出
			line(img1, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);

			cout << "djfkljsa " << "(" << x1 << "," << y1 << ")" << " " << "(" << x2 << "," << y2 << ")" << endl;
			//line(canny, Point2d(x1, y1), Point2d(x2, y2), Scalar(0, 255, 255), 2);
		}
	}

	imgShow = img1;
	resize(imgShow, imgShow, Size(imgShow.cols / 4, imgShow.rows / 4));
	imshow("imgShow2", imgShow);
	imwrite("shuchu2.png", imgShow);
	waitKey(0);
	return 0;
};

结果图如下所示：

 

 终于弄出来了，去干饭。