车道线检测--Hough变换

最新推荐文章于 2022-12-29 20:50:33 发布
最新推荐文章于 2022-12-29 20:50:33 发布
阅读量909 收藏 8
点赞数 1
分类专栏： CV c++ 文章标签： opencv 边缘检测 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41587270/article/details/108408010
版权

车道线检测，尝试用传统的方法识别车道线，可以节约硬件资源，但由于场景太复杂，后面还是采用网络模型识别，不过可以作为预判：

#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

int lane_roi_hulf(cv::Mat& img_gray, cv::Mat& img_hulf);
int lane_roi(cv::Mat& img_canny, cv::Mat& img_roi);
std::vector<std::vector<cv::Vec4i>> line_separa(std::vector<cv::Vec4i> lines, cv::Mat& img_edges);
std::vector<cv::Point> regression(std::vector<std::vector<cv::Vec4i> > left_right_lines, cv::Mat& inputImage);
int find_contour(cv::Mat& img_roi, cv::Mat& img_contour);
int lane_compel(cv::Mat& img_lane);

int main(int argc, char** argv) {
	cv::Mat img_input, img_guas, img_gray, img_canny;
	cv::Mat img_hulf, img_roi, img_roi_cont;
	img_input = cv::imread("./img/city_03_16_229.jpg");
	cv::Mat img_uch(img_input.rows, img_input.cols, CV_8UC1, cv::Scalar::all(0));

	double time_start = static_cast<double>(getTickCount());
	cv::cvtColor(img_input, img_gray, COLOR_BGR2GRAY);
	//lane_roi_hulf(img_gray, img_hulf);

	cv::GaussianBlur(img_gray, img_guas, cv::Size(5, 5), 0, 0);
	cv::threshold(img_guas, img_uch, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);

	lane_roi(img_uch, img_roi_cont);
	cv::imshow("img_roi_cont", img_roi_cont);

	cv::Canny(img_guas, img_canny, 100, 250);
	cv::imshow("img_canny", img_canny);

	lane_roi(img_canny, img_roi);
	//double time = (static_cast<double>(getTickCount()) - time_start) / getTickFrequency();
	//std::cout<<"time: "<<time<<std::endl;
	cv::imshow("img_roi", img_roi);

	std::vector<cv::Vec4i> lines;
	HoughLinesP(img_roi, lines, 1, CV_PI / 180, 40, 40, 20);

	cv::Mat img_contour = cv::Mat::zeros(img_roi.size(), img_roi.type());
	find_contour(img_roi_cont, img_contour);
	imshow("img_contour", img_contour);

	cv::Mat img_hough = cv::Mat::zeros(img_uch.size(), img_uch.type());
	int j = 0 ;
	cv::Point hough_ini, hough_fini;	
	for(auto i : lines) {
		hough_ini = cv::Point(i[0], i[1]);
		hough_fini = cv::Point(i[2], i[3]);
		cv::line(img_hough, hough_ini, hough_fini, cv::Scalar(255), 1, CV_AA);
		j++;
	}
	std::cout<<"j: "<<j<<std::endl;
	cv::imshow("img_hough", img_hough);

	std::vector<std::vector<cv::Vec4i> > left_right_lines;
	std::vector<cv::Point> lanes;
	left_right_lines = line_separa(lines, img_roi);
	lanes = regression(left_right_lines, img_roi);

	cv::Mat img_lane = cv::Mat::zeros(img_hough.size(), img_hough.type());
	int k = 0;
	cv::Point left_ini, left_fini;
	for(auto i : left_right_lines[0]) {
		left_ini = cv::Point(i[0], i[1]);
		left_fini = cv::Point(i[2], i[3]);
		cv::line(img_lane, left_ini, left_fini, cv::Scalar(255), 1, CV_AA);
		k++;
	}

	cv::Point right_ini, right_fini;
	for(auto i : left_right_lines[1]) {
		right_ini = cv::Point(i[0], i[1]);
		right_fini = cv::Point(i[2], i[3]);
		cv::line(img_lane, right_ini, right_fini, cv::Scalar(255), 1, CV_AA);
		k++;
	}
	std::cout<<"k: "<<k<<std::endl;

	cv::line(img_lane, cv::Point(640, 0), cv::Point(640, 720), cv::Scalar(255), 1, CV_AA);
	//cv::line(img_lane, lanes[0], lanes[1], cv::Scalar(255), 1, CV_AA);
	//cv::line(img_lane, lanes[2], lanes[3], cv::Scalar(255), 1, CV_AA);
	cv::imshow("img_lane", img_lane);

	cv::waitKey(0);
	return 0;
}

int lane_roi(cv::Mat& img_canny, cv::Mat& img_roi)
{
	int rows_kerl =  img_canny.rows / 10;
	int cols_kerl =  img_canny.cols / 10;
	cv::Mat img_fill = cv::Mat::zeros(img_canny.size(), img_canny.type());
	img_fill.copyTo(img_roi);

	cv::Point pts[4] = {
		cv::Point(3 * cols_kerl, 6 * rows_kerl),
		cv::Point(7 * cols_kerl, 6 * rows_kerl),
		cv::Point(9.5 * cols_kerl, 10 * rows_kerl),
		cv::Point(0.5 * cols_kerl, 10 * rows_kerl)
	};

	cv::fillConvexPoly(img_fill, pts, 4, cv::Scalar(255));
	cv::bitwise_and(img_canny, img_fill, img_roi);
}

int lane_roi_hulf(cv::Mat& img_gray, cv::Mat& img_hulf)
{
	cv::Mat img_fill = cv::Mat::zeros(img_gray.size(), img_gray.type());
	img_fill.copyTo(img_hulf);

	cv::Point pts[4] = {
		cv::Point(0, img_gray.rows / 2),
		cv::Point(img_gray.cols, img_gray.rows / 2),
		cv::Point(img_gray.cols, img_gray.rows),
		cv::Point(0, img_gray.rows),
	};
	cv::fillConvexPoly(img_fill, pts, 4, cv::Scalar(255));
	cv::bitwise_and(img_gray, img_fill, img_hulf);
}

std::vector<std::vector<cv::Vec4i>> line_separa(std::vector<cv::Vec4i> lines, cv::Mat& img_edges)
{
	std::vector<std::vector<cv::Vec4i> > output(2);
	size_t j = 0, m = 0, n = 0;
	cv::Point ini, fini;
	double slope_thresh_min = 0.3;
	double slope_thresh_max = 10;
	std::vector<double> slopes, slope_left, slope_right;
	std::vector<cv::Vec4i> selected_lines, sel_line_left, sel_line_right;
	std::vector<cv::Vec4i> right_lines, left_lines;

	// Calculate the slope of all the detected lines
	for (auto i : lines) {
		ini = cv::Point(i[0], i[1]);
		fini = cv::Point(i[2], i[3]);

		// Basic algebra: slope = (y1 - y0)/(x1 - x0)
		double slope = (static_cast<double>(fini.y) - static_cast<double>(ini.y)) / 
			(static_cast<double>(fini.x) - static_cast<double>(ini.x) + 0.00001);

		// If the slope is too horizontal, discard the line
		// If not, save them  and their respective slope
		if (std::abs(slope) > slope_thresh_min && std::abs(slope) < slope_thresh_max) {
			slopes.push_back(slope);
			selected_lines.push_back(i);
		}
	}

	// Split the lines into right and left lines
	double img_center = static_cast<double>((img_edges.cols / 2));
	while (j < selected_lines.size()) {
		ini = cv::Point(selected_lines[j][0], selected_lines[j][1]);
		fini = cv::Point(selected_lines[j][2], selected_lines[j][3]);

		// Condition to classify line as left side or right side
		if (slopes[j] > 0 && fini.x > img_center && ini.x > img_center) {
			right_lines.push_back(selected_lines[j]);
			//right_flag = true;
		}

		else if (slopes[j] < 0 && fini.x < img_center && ini.x < img_center) {
			left_lines.push_back(selected_lines[j]);
			//left_flag = true;
		}
		j++;
	}

	while (m < right_lines.size()) {
		ini = cv::Point(right_lines[m][0], right_lines[m][1]);
		fini = cv::Point(right_lines[m][2], right_lines[m][3]);

		// Basic algebra: slope = (y1 - y0)/(x1x1 - x0)
		double slope = (static_cast<double>(fini.y) - static_cast<double>(ini.y)) / 
			(static_cast<double>(fini.x) - static_cast<double>(ini.x) + 0.00001);
		double interc = fini.y - slope * fini.x;

		std::cout<<"slope1: "<<slope<<", interc1: "<<interc<<std::endl;
		slope_right.push_back(slope);
		sel_line_right.push_back(right_lines[m]);
		
		m++;
	}

	while (n < left_lines.size()) {
		ini = cv::Point(left_lines[n][0], left_lines[n][1]);
		fini = cv::Point(left_lines[n][2], left_lines[n][3]);

		// Basic algebra: slope = (y1 - y0)/(x1x1 - x0)
		double slope = (static_cast<double>(fini.y) - static_cast<double>(ini.y)) / 
			(static_cast<double>(fini.x) - static_cast<double>(ini.x) + 0.00001);
		double interc = fini.y - slope * fini.x;

		std::cout<<"slope2: "<<slope<<", interc2: "<<interc<<std::endl;
		// If the slope is too horizontal, discard the line
		// If not, save them  and their respective slope
		if (std::abs(slope) > slope_thresh_min && std::abs(slope) < slope_thresh_max) {
			slope_left.push_back(slope);
			sel_line_left.push_back(left_lines[n]);
		}
		n++;
	}

	output[0] = right_lines;
	output[1] = left_lines;
	return output;
}

std::vector<cv::Point> regression(std::vector<std::vector<cv::Vec4i> > left_right_lines, cv::Mat& inputImage)
{
	std::vector<cv::Point> output(4);
	cv::Point ini, fini;
	cv::Point ini2, fini2;
	cv::Vec4d right_line, left_line;
	std::vector<cv::Point> right_pts, left_pts;

	cv::Point right_b;  // Members of both line equations of the lane boundaries:
	double right_m;  // y = m*x + b
	cv::Point left_b;  //
	double left_m;  //

	// If right lines are being detected, fit a line using all the init and final points of the lines
	for (auto i : left_right_lines[0]) {
		ini = cv::Point(i[0], i[1]);
		fini = cv::Point(i[2], i[3]);
		right_pts.push_back(ini);
		right_pts.push_back(fini);
	}

	if (right_pts.size() > 0) {
		// The right line is formed here
		cv::fitLine(right_pts, right_line, CV_DIST_L2, 0, 0.01, 0.01);
		right_m = right_line[1] / right_line[0];
		right_b = cv::Point(right_line[2], right_line[3]);
		}

	// If left lines are being detected, fit a line using all the init and final points of the lin

	for (auto j : left_right_lines[1]) {
		ini2 = cv::Point(j[0], j[1]);
		fini2 = cv::Point(j[2], j[3]);
		left_pts.push_back(ini2);
		left_pts.push_back(fini2);
	}

	if (left_pts.size() > 0) {
		// The left line is formed here
		cv::fitLine(left_pts, left_line, CV_DIST_L2, 0, 0.01, 0.01);
		left_m = left_line[1] / left_line[0];
		left_b = cv::Point(left_line[2], left_line[3]);
		}

	// One the slope and offset points have been obtained, apply the line equation to obtain the line points
	int ini_y = inputImage.rows;
	int fin_y = 470;

	double right_ini_x = ((ini_y - right_b.y) / right_m) + right_b.x;
	double right_fin_x = ((fin_y - right_b.y) / right_m) + right_b.x;

	double left_ini_x = ((ini_y - left_b.y) / left_m) + left_b.x;
	double left_fin_x = ((fin_y - left_b.y) / left_m) + left_b.x;

	output[0] = cv::Point(right_ini_x, ini_y);
	output[1] = cv::Point(right_fin_x, fin_y);
	output[2] = cv::Point(left_ini_x, ini_y);
	output[3] = cv::Point(left_fin_x, fin_y);

	return output;
}

int find_contour(cv::Mat& img_roi, cv::Mat& img_contour)
{
	//寻找轮廓
	vector<vector<Point>> contours;
	findContours(img_roi, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

	for (int i = 0; i < contours.size(); i++) {
		//计算面积与周长
		double length = arcLength(contours[i], true);
		double area = contourArea(contours[i]);

		//外部矩形边界
		Rect rect = boundingRect(contours[i]);
		int h = img_roi.rows - 50;
		
		//轮廓分析：
		if (length < 50.0 || area < 10.0) {
			continue;
		}
		//cout << "length:" << length << endl;
		//cout << "area:" << area << endl;

		/*
		//最小包围矩形
		RotatedRect rrt = minAreaRect(contours[i]);
		//关于角度问题：https://blog.csdn.net/weixin_41887615/article/details/91411086

		double angle = abs(rrt.angle);
		//angle < 50.0 || angle>89.0
		
		if (angle < 20.0 || angle > 89.0) {
			continue;
		}
		*/
		if (contours[i].size() > 5) {
			//用椭圆拟合
			RotatedRect errt = fitEllipse(contours[i]);

			if ((errt.angle < 5.0) || (errt.angle > 160.0)) {
				//if (80.0 < errt.angle && errt.angle < 100.0) {
					continue;
				//}
			}
		}

		drawContours(img_contour, contours, i, Scalar(255), 1, 8);
	}

	return 0;
}

//g++ -std=c++14 lane_test3.cpp -o lane_test3 -lopencv_core -lopencv_highgui -lopencv_videoio -lopencv_imgproc -lopencv_imgcodecs
Hough变换与FCM算法相结合检测车道线
IT荻的博客
03-04 1976
https://blog.csdn.net/u010712012/article/details/87477554 之前一小段时间分析的三大块，车辆检测，车道线检测，车辆压线判别。 主要分析了一下车道线检测的优化问题，经过图像处理，canny边缘检测，Hough变换检测出的图如第二幅 因为车道是具有双边缘的，所以根据之前的车道线检测算法检测出来的直线会有不止一条，如果能够用一种算法把多条...
[OpenCV4] Hough变换从理论到实现车道线检测
...
11-26 1079
目录 效果预览 0.Hough变换的理论基础 0.0 简介 0.1 对直线的分析 1 OpenCV中的Hough直线变换 1.1HoughLines() 1.1.1 The Standard Hough Transform 1.1.2 Demo 1.2HoughLinesP() 1.2.1The Probabilistic Hough Line Transform 1...
hough变换_霍夫变换——形状特征提取算法：车道线检测
weixin_39634480的博客
11-28 1533
霍夫变换是一种特征提取，被广泛应用在图像分析、电脑视觉以及数位影像处理。霍夫变换是用来辨别找出物件中的特征，例如：线条。他的算法流程大致如下，给定一个物件、要辨别的形状的种类，算法会在参数空间中执行投票来决定物体的形状，而这是由累加空间(accumulator space)里的局部最大值来决定。理论上，霍夫变换就是对于原图上的每一个直线都在参数空间画一条线，最终找出参数空间变换线比较密...
基于改进Hough变换的车道线检测技术
08-07
基于改进Hough变换的车道线检测技术 详细描述 了 基于改进的Hough车道检测技术
51.已知形状的曲线检测---Hough变换法.pdf
06-17
例如，在自动驾驶车辆中，Hough变换可以用来检测道路上的车道线，帮助车辆定位和导航。在医学图像处理中，它可以用来识别细胞组织的边界，或者帮助诊断某些疾病。 总之，Hough变换法在图像处理中的作用不容小觑，它...
基于opencv传统数字图像处理实现车道线检测-python-c++源码+项目说明.zip
11-05
车道线检测方法，主要包括获取感兴趣区域（ROI）、形态学闭运算、基于Hough变换的直线检测。 基于opencv传统数字图像处理实现车道线检测_python_c++源码+项目说明.7z 【实现方法】 实现车道线检测，主要包含两部分...
matlab 车道线检测-其它代码类资源
07-22
本资源提供了基于改进的Hough变换和区域生长法的MATLAB车道线检测算法。 Hough变换是一种在图像中寻找直线或曲线的经典方法，其基本思想是将图像空间中的直线参数化，转换到Hough空间中，通过在Hough空间中查找峰值...
【车道线检测】基于matlab Hough变换图片车道线检测 【含Matlab源码 276期】.md
最新发布
10-14
图像识别：表盘识别、车道线识别、车牌识别、答题卡识别、电器识别、跌倒检测、动物识别、发票识别、服装识别、汉字识别、红绿灯识别、火灾检测、疾病分类、交通标志牌识别、口罩识别、裂缝识别、目标跟踪、疲劳检测...
Hough变换检测直线
04-15
使用MATLAB实现Hough变换，检测车道线的demo程序
基于MATLAB和改进Hough变换的车道线检测
11-21
基于matlab的车道线检测程序，对比不同边缘检测算法，通过改进hough变换来检测视频中的车道线，每一步算法都具有详细的解释说明
用于车道线检测的代码，其中用到了hough变换，能有效实现车道线的检测，matlab源码
03-16
【达摩老生出品，必属精品，亲测校正，质量保证】 资源名：用于车道线检测的代码，其中用到了hough变换，能有效实现车道线的检测，matlab源码 资源类型：matlab项目全套源码 源码说明： 全部项目源码都是经过测试校正后百分百成功运行的，如果您下载后不能运行可联系我进行指导或者更换。 适合人群：新手及有一定经验的开发人员
利用c++实现车道线识别.pdf
08-06
本篇文章是在学习C++的时候做的小项目，对目前的方法进行了稍微的改动，效果还可以。目前车道线检测方面的方法主要包括：基于Hough变换、基于透视变换、基于机器学习和深度学习。其中第一种方法是根据车道线与周围环境的物理特征差异进行图像的处理，从而检测到车道线，该方法复杂度较低，实时性较高，但易受到道路环境的干扰，而且Hough变换的直线检测特质导致了该方法在道路曲率较大时的检测误差较大。本文是利用c++和Hough变换实现对车道线的检测。
hough变换检测直线的程序
05-02
基于霍夫变换的图像直线检测程序，使用matlab编程
【车道线检测】基于matlab Hough变换视频车道线检测 【含Matlab源码 274期】
订阅付费专栏Matlab（奶茶价版），可赠送奶茶价版付费专栏指定代码1份；
02-10 4758
Hough变换视频车道线检测 完整代码，直接运行，适合小白！可提供运行操作视频！
【图像检测-道路检测】基于hough变换实现道路检测直线检测附matlab代码
matlab_dingdang的博客
08-24 889
随着遥感技术和计算机技术的飞速发展,遥感图像的采集变得越来越容易,遥感图像中的物体特征识别及检测变得越来越重要,直线是图像中物体基本的特征之一,研究图像中直线的检测算法对计算机视觉和模式识别具有重要意义.遥感图像中的直线道路信息是遥感图像分析中非常重要的地理信息,因此研究关于直线道路检测的算法已经成为国内外遥感领域的重点.Hough变换作为直线特征提取的比较典型的算法,已经在许多应用系统中获得很好的应用.Hough变换实质上是把数字图像空间中有一定关系的像素点进行聚类,具有很好的鲁棒性,可以很好的解决直线特
基于边缘检测与Hough变换的车道线检测
m0_59833680的博客
08-17 4429
基于边缘检测与Hough变换的车道线检测第一章：绪论1.1 研究意义及背景 高速公路的通行里程是一个国家发展水平的重要标志之一。高速公路具有车辆通行能力大、交通事故少、经济效益高的特点，它的不断发展引起了经济社会的重大变革，不仅有力地改变了人们的时空观念和地域观念，更促进了公路沿线地区社会和经济的发展，便利了沿线地区人们的出行，人们的生活质量和办事效率也得到了极大提高。汽车是高速公路的重要载体...
【车道线检测】Hough变换视频车道线检测 【含Matlab源码 274期】
订阅付费专栏Matlab（奶茶价版），可赠送奶茶价版付费专栏指定代码1份；
12-29 307
Hough变换视频车道线检测 完整的代码，方可运行；可提供运行操作视频！适合小白！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值