python+openCV (入门级)车道线检测学习笔记

Posted 2023-04-05 稚晖君的小弟

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python+openCV (入门级)车道线检测学习笔记相关的知识，希望对你有一定的参考价值。

文章目录

前言
一、openCV安装
二、尝试使用cv2中库函数
三、Canny边缘检测
四、ROI and mask
五、霍夫变换
六、离群值过滤
七、最小二乘法拟合
八、车道线标注
九、视频读写
十、其他
总结
附视频检测完整程序

前言

本文使用python+openCV
用到的算法：
高斯滤波
Canny边缘检测
ROI和mask
霍夫变换
离群值过滤
最小二乘法拟合

一、openCV安装

win+x选择运行，然后输入cmd
输入pip install opencv-python等待安装
在IDLE中新建脚本.py文件，输入import cv2,如果无报错即为安装成功。
再输入print(cv2.__version__)可查看openCV版本。

二、尝试使用cv2中库函数

1.读取图片

cv2.imread(const String & filename, int flags = IMREAD_COLOR)

第一个参数是窗口的名字，第二个参数是读取格式（彩色或灰度），函数返回值是图片转换格式后所对应的列表。

如img = cv2.imread('img.jpg',cv2.IMREAD_GRAYSCALE)

2.图片显示

cv2.imshow(window_name, img)

第一个参数是窗口的名字，可以创建多个窗口，但是必须给他们不同的名字。第二个参数是显示格式，可以是img图片格式，也可以是mat数组格式。

3.延时/暂停

cv2.waitKey(int x)

相当于程序延时，调整cv2.imshow()的显示时间。延时时间为x毫秒。返回值为在延时期间按下键盘上按键所对应的ASCII值。

x=0时，即cv2.waitKey(0)表示程序停在此处，直到手动关闭cv2.imshow()的窗口。
例如设计一个，无穷延时，当键盘按下q时退出。

if cv2.waitKey(1) & 0xFF == ord(‘q’): break  
#ord()是将字符转换为ASCII码

4.保存图片

cv2.imwrite(newfile_name, img)

第一个参数是保存的新图片的文件名，第二个参数是应保存的图片对应的列表。

5.清楚所有窗口

cv2.destroyAllWindows()

关闭所有openCV打开的窗口。

三、Canny边缘检测

CV2提供了提取图像边缘的函数canny。其算法思想如下：
1. 使用高斯模糊，去除噪音点（cv2.GaussianBlur）
2. 灰度转换（cv2.cvtColor）
3. 使用sobel算子，计算出每个点的梯度大小和梯度方向
4. 使用非极大值抑制(只有最大的保留)，消除边缘检测带来的杂散效应
5. 应用双阈值，来确定真实和潜在的边缘
6. 通过抑制弱边缘来完成最终的边缘检测

1.高斯滤波

gaussian = cv2.GaussianBlur(color_img, (gaussian_ksize,gaussian_ksize), gaussian_sigmax)

color_img 输入图片
gaussian_ksize 高斯核大小，可以为方形矩阵，也可以为矩形
gaussian_sigmax X方向上的高斯核标准偏差
~~没看太懂这个函数，目前仅局限于搬来直接用，下次一定~~

2.图片转换

gray_img = cv2.cvtColor(input_image, flag)

用于颜色空间转换。input_image为需要转换的图片，flag为转换的类型，返回值为颜色空间转换后的图片矩阵。flag对应：
cv2.COLOR_BGR2GRAY BGR -> Gray
cv2.COLOR_BGR2RGB BGR -> RGB
cv2.COLOR_BGR2HSV BGR -> HSV
可以了解一下该函数和cv2.imread()的区别

3.边缘检测

edge_img = cv2.Canny(gray_img,canny_threshold1,canny_threshold2)

imag为所操作的图片，threshold1为下阈值，threshold2为上阈值，返回值为边缘图。

四、ROI and mask

利用数组选取ROI(region of interest,感性趣的区域，然后与原图进行布尔运算(与运算)。

poly_pts = numpy.array([[[0,368],[300,210],[340,210],[640,368]]])

四个数组创建后保存在变量poly_pts中。

mask = np.zeros_like(gray_img)

构建一个与gray_img同维度的数组，并初始化所有变量为零。

cv2.fillPoly(mask, pts, color)

绘制多边形函数。mask为绘制对像，pts为绘制范围，color为绘制颜色。

img_mask = cv2.bitwise_and(gray_img, mask)

与运算

五、霍夫变换

得到一系列的直线

lines = cv2.HoughLinesP(edge_img,  1, np.pi / 180, 15, minLineLength=40, maxLineGap=20)

edge_img: 要检测的图片矩阵
参数2: 距离r的精度,值越大,考虑越多的线
参数3: 距离theta的精度,值越大,考虑越多的线
参数4: 累加数阈值,值越小,考虑越多的线
minLineLength: 最短长度阈值,短于这个长度的线会被排除
maxLineGap:同一直线两点之间的最大距离
返回值::
[np.array([[x_1,y_1, x_2, y_2]]),
np.array([[x_1, y_1, x_2, y_2]]),
…,
np.array([[x_1, y_1, x_2, y_2]])]

六、离群值过滤

循环查找超出设定范围的斜率，并去除。

idx = np.argmax(diff)

当diff中存放的是一维时，找到diff中最大的数值，并返回该值所在位置。

示例：
one_dim_array = np.array([1, 4, 5, 3, 7, 2, 6])
print(np.argmax(one_dim_array))

打印结果为	4

lines.pop(idx)

从列表lines中把第idx数去除

七、最小二乘法拟合

获得左车道线和右车道线的理想直线

x_coords = np.ravel([[line[0][0], line[0][2]] for line in lines])

将多维数组降为一维
~~还未想明白转换关系，下次一定~~

poly = np.polyfit(x, y, deg)

x, y为各个点的横纵坐标，deg为拟合曲线的次数

y_e = np.polyval(poly, x)

拟合曲线之后，x在曲线上对应的y值

八、车道线标注

cv2.line(img, tuple(line[0]), tuple(line[1]), color,thickness)

在图片上画线，img为所标注的目标图片，ine[0]为起点坐标，line[1]为终点坐标，thickness为线宽。
注意两个坐标需要为tuple元组格式，即tuple(line[0])

九、视频读写

1.打开视频

capture = cv2.VideoCapture('video.mp4')

如果为cv2.VideoCapture(0)，表示打开笔记本的内置摄像头。

2.按帧读取视频

ret, frame = capture.read()

其中ret是布尔值，如果读取帧是正确的则返回True，如果文件读取到结尾，它的返回值就为False。
frame就是每一帧的图像，是个三维矩阵。

3.视频编码格式设置

fourcc = cv2.VideoWriter_fourcc('X', 'V', 'I', 'D')

fourcc意为四字符代码（Four-Character Codes），顾名思义，该编码由四个字符组成,下面是VideoWriter_fourcc对象一些常用的参数，注意：字符顺序不能弄混
cv2.VideoWriter_fourcc(‘I’, ‘4’, ‘2’, ‘0’),该参数是YUV编码类型，文件名后缀为.avi
cv2.VideoWriter_fourcc(‘P’, ‘I’, ‘M’, ‘I’),该参数是MPEG-1编码类型，文件名后缀为.avi
cv2.VideoWriter_fourcc(‘X’, ‘V’, ‘I’, ‘D’),该参数是MPEG-4编码类型，文件名后缀为.avi
cv2.VideoWriter_fourcc(‘T’, ‘H’, ‘E’, ‘O’),该参数是Ogg Vorbis,文件名后缀为.ogv
cv2.VideoWriter_fourcc(‘F’, ‘L’, ‘V’, ‘1’),该参数是Flash视频，文件名后缀为.flv

4.写视频参数设置

outfile = cv2.VideoWriter(filename, fourcc, 25, (1280,368))

filename为写入视频的文件名，fourcc为视频编码格式cv2.VideoWriter_fourcc()的返回值，25为帧率，(1280,368)为视频大小。

ret, frame = capture.read()

第一个参数ret 为布尔值即True 或者False,代表有没有读取到图片，第二个参数frame表示截取到一帧的图片

output = np.concatenate((origin, frame), axis=1)

能够一次完成多个数组的拼接
不写axis参数的话，默认为按列拼接；若axis = 1的话，即为按行拼接；
~~axis参数意义没搞太明白，下次一定~~

十、其他

程序存在小bug但不影响检测视频生成，如果哪位大佬知道bug怎么解决记得踢我一脚。
cv2.imshow()总是卡住无响应，无法自己关闭窗口，使用cv2.destroyAllWindows()也还是卡住；
而且报告错误：

error: OpenCV(4.5.5) D:\\a\\opencv-python\\opencv-python\\opencv\\modules\\imgproc\\src\\smooth.dispatch.cpp:617: error: (-215:Assertion failed) !_src.empty() in function 'cv::GaussianBlur'

> 卡住的问题有人说是openCV对一部分硬件的适配不好，我比较在赞成这种观点。 报错  cv2.error  error:
> (-215:Assertion failed) dst.data == (uchar*)dst_ptr in function
> 'cvShowImage'
> 
> 同样的代码，我发现在公司电脑1060上，cv2.imshow()就可以显示，但在自己2080ti上就总是报错如上。于是锁定在cv2版本问题，果然卸掉最新的4.0版本，换上3.4.4.19就好了。
> 
> 可能是4.0版本与2080ti的卡还不兼容。
> 来源：https://blog.csdn.net/qq_39938666/article/details/88179966

报错的问题目前未解决，也修改不掉。

总结

完全实现对视频形式的单车道直线行驶时对车道线检测和标注。

附视频检测完整程序

import cv2
import numpy as np

#高斯滤波+canny边缘检测
def get_edge_img(color_img, gaussian_ksize=5, gaussian_sigmax=1,
                 canny_threshold1=50, canny_threshold2=100):
    #param intoduction
    #color_img 输入图片    gaussian_ksize 高斯核大小
    #gaussian_sigmax X方向上的高斯核标准偏差
    gaussian = cv2.GaussianBlur(color_img, (gaussian_ksize, gaussian_ksize),
                                gaussian_sigmax)
    gray_img = cv2.cvtColor(gaussian,cv2.IMREAD_GRAYSCALE)
    edge_img = cv2.Canny(gray_img,canny_threshold1,canny_threshold2);
    return edge_img

def roi_mask(gray_img):
    poly_pts = np.array([[[0,368],[300,210],[340,210],[640,368]]])
    mask = np.zeros_like(gray_img)
    cv2.fillPoly(mask, pts=poly_pts, color=255)
    img_mask = cv2.bitwise_and(gray_img, mask)
    return img_mask

def get_lines(edge_img):
    
    #斜率计算
    def calculate_slope(line):
        x_1, y_1, x_2, y_2 = line[0]
        slope = (y_2-y_1)/(x_2-x_1)
        return slope

    #离群值过滤
    def reject_abnormal_lines(lines, threshold):
        slopes = [calculate_slope(line) for line in lines]
        while len(lines)>0:
            mean = np.mean(slopes)
            diff = [abs(s-mean) for s in slopes]
            idx = np.argmax(diff)
            if diff[idx]>threshold:
                slopes.pop(idx)
                lines.pop(idx)
            else:
                break
        return lines
    
    #最小二乘拟合
    def least_squares_fit(lines):
    
        x_coords = np.ravel([[line[0][0], line[0][2]] for line in lines])
        y_coords = np.ravel([[line[0][1], line[0][3]] for line in lines])
        # 2. 进行直线拟合.得到多项式系数
        poly = np.polyfit(x_coords, y_coords, deg=1)
        # 3. 根据多项式系数,计算两个直线上的点,用于唯一确定这条直线
        point_min = (np.min(x_coords), np.polyval(poly, np.min(x_coords)))
        point_max = (np.max(x_coords), np.polyval(poly, np.max(x_coords)))
        return np.array([point_min, point_max],dtype=np.int0)

    lines = cv2.HoughLinesP(edge_img, 1, np.pi/180, 15, minLineLength=40, maxLineGap=20)

    left_lines = [line for line in lines if calculate_slope(line)<0]
    right_lines = [line for line in lines if calculate_slope(line)>0]
    
    left_lines = reject_abnormal_lines(left_lines, threshold=0.2)
    right_lines = reject_abnormal_lines(right_lines, threshold=0.2)

    return least_squares_fit(left_lines),least_squares_fit(right_lines)

def draw_line(img, lines):
    left_line, right_line = lines
    cv2.line(img, tuple(left_line[0]), tuple(left_line[1]), color=(0,255,255),thickness=5)
    cv2.line(img, tuple(right_line[0]), tuple(right_line[1]), color=(0,255,255),thickness=5)

def show_lane(color_img):
    edge_img = get_edge_img(color_img)
    mask_gray_img = roi_mask(edge_img)
    lines = get_lines(mask_gray_img)
    draw_line(color_img, lines)
    return color_img

if __name__ == '__main__':
    capture = cv2.VideoCapture('video.mp4')
    fourcc = cv2.VideoWriter_fourcc('X', 'V', 'I', 'D')
    outfile = cv2.VideoWriter('output.avi', fourcc, 25, (1280,368))

    while True:
        ret, frame = capture.read() 
        origin = np.copy(frame)
        frame = show_lane(frame)
        output = np.concatenate((origin, frame), axis=1)
        outfile.write(output)
        cv2.imshow('video', output)
        cv2.waitKey(10)

分步操作检测图片和检测视频的源码、测试图片和测试视频连接：https://download.csdn.net/download/qq_27839923/75831347

opencv入门项目——车道线检测

文章目录

Canny 边缘检测

import cv2

img = cv2.imread('img.jpg', cv2.IMREAD_GRAYSCALE)

edge_img = cv2.Canny(img, 50, 100)

cv2.imshow('edges', edge_img)
cv2.waitkey(0)

有小噪点，可通过调高阈值解决

edge_img = cv2.Canny(img, 70, 120)

cv2.imshow('edges', edge_img)
cv2.waitkey(0)

相比于之前，边缘明显减少

小程序

import cv2

cv2.namedWindow('edge_detection')
cv2.createTrackbar('minThreshold', 'edge_detection', 50, 1000, lambda x: x)
cv2.createTrackbar('maxThreshold', 'edge_detection', 100, 1000, lambda x: x)
img = cv2.imread('img.jpg', cv2.IMREAD_GRAYSCALE)

while True:
	minThreshold = cv2.getTrackbarPos('minThreshold', 'edge_detection')
	maxThreshold = cv2.getTrackbarPos('maxThreshold', 'edge_detection')
	edges = cv2.Canny(img, minThreshold, maxThreshold)
	cv2.imshow('edge_detection', edges)
	cv2.waitKey(10)A

阈值增加，强边缘减少，随之也会导致弱边缘减少

roi_mask

理论

通过 Canny 边缘检测算法，获取了边缘信息。但还有很多无关信息，对于车道信息没有意义，还会造成干扰，所以要将其剔除。

在C++版本中有实现ROI这个函数
但在Python版本中，没有实现图片数据结构，而是将图片保存为 numpy 数组。
所以在python 版本中实现ROI，有以上两种方法。
数组切片，取出来的是个矩形区域

实现

ROI（region of interest，感兴趣的区域）
- 数组切片
- 布尔运算（与运算）
图像以矩阵 np.array 形式存储在内存中
- np.zeros_like
cv2.fillPoly
cv2.bitwise_and / np.bitwise_and

import cv2
import numpy as np

edge_img = cv2.imread('edges_img.jpg', cv2.IMREAD_GRAYSCALE)
mask = np.zeros_like(edge_img)
cv2.fillPoly(mask, np.array([[[0 ,368], [240, 210], [300, 210], [640, 368]]], color=255)

注意输入点的顺序

masked_edge_img = cv2.bitwise_and(edge_img, mask)
cv2.imshow('masked', masked_edge_img)
cv2.waitKey(0)

生成图片只保留车道线所需要的信息，当然 ROI 这里没有提取好。

霍夫变换

基本原理

API

官方文档

实现

import cv2
import numpy as np

img = np.zeros((200, 400))
cv2.line(img, (10, 10), (200， 100)， 255， 3)
cv2.line(img, (30, 50), (350, 10), 255, 2)

cv2.imshow('img', img)
cv2.imwrite('lines.jpg', img)
cv2.waitKey(0)

霍夫变换只针对灰度图

import cv2
import numpy as np

cv2.imread('lines.jpg', cv2.IMREAD_GRAYSCALE)
lines = cv2.HoughLinesP(img, 1, np.pi/180, 15, minLineLength=40, maxLineGap=20)

print(len(lines))

图像中只有两条直线，却找到32条直线。
这是因为画出的直线是有一定宽度的，在这两条直线之间，拟合出来来了很多直线

解决：
根据斜率进行分类
再通过最小二乘法拟合成一条直线

def calculate_slope(line):
	"""
	计算线段line的斜率
	:param line: np.array([[x_1, y_1, x_2, y_2]])
	:return:
	"""
	x_1, y_1, x_2, y_2 = line[0]
	if x_1 == x_2:
		return (y_2-y_1) / (x_2-x_1+1)
	else:
		return (y_2-y_1) / (x_2-x_1)


edge_img = cv2.imread('masked_edge_img.jpg', cv2.IMREAD_GRAYSCALE)
# 获取所有线段
lines = cv2.HoughlinesP(edge_img, 1, np.pi/180, 15, minLineLength=40, maxLineGap=20)
# 按照斜率分成车道线
left_lines = [line for line in lines if calculate_slope(line) > 0]
right_lines = [line for line in lines if calculate_slope(line) < 0]

离群值过滤

因为误差，有些直线会被误识别，但他们可能不属于左直线和右直线。
通过特征，来排除。直线的特征就是斜率。
将与平均斜率相差太大的线排除。

def reject_abnormal_lines(lines, threshold):
	"""
	剔除斜率不一致的线段
	:param lines：线段集合，[np.array([[x_1, y_1, x_2, y_2]]), np.array([[x_1, y_1, x_2, y_2]])
	"""
	slopes = [calculate_slope(line) for line in lines]
	while len(lines) > 0:
		mean = np.mean(slopes)
		diff = [abs(s - mean) for s in slopes]
		idx = np.argmax(diff)
		if diff[idx] > threshold:
			slopes.pop(idx)
			lines.pop(idx)
		else:
			break
	return lines


reject_abnormal_lines(left_lines, threshold=0.2)
reject_abnormal_lines(right_lines, threshold=0.2)

最小二乘拟合

API

np.ravel 将高维数组拉成一维
np.polyfit 多项式拟合
np.polyval 多项式求值

a = np.array([[2, 3], [4, 5]])
print(a)

a.ravel()

poly = np.polyfit([0, 3, 6, 9], [0, 5, 9, 14], deg=1)	# deg 为几维矩阵
print(poly)

得到一个数对，两个参数

x = 0
print(poly[0] * x + poly[1])
np.polyval(poly, 10)	# 上下两种形式一样

实现

def least_squares_fit(lines):
	"""
	将lines中的线段拟合成一条线段
	:param lines：线段集合，[np.array([[x_1, y_1, x_2, y_2]]), np.array([[x_1, y_1, x_2, y_2]]),...,np.array([[x_1, y_1, x_2, y_2]])]
	:return：线段上的两点，np.array([[xmin, ymin], [xmax, ymax]])
	"""

	# 1. 去除所有坐标点
	x_coords = np.ravel([[line[0][0], line[0][2]] for line in lines])
	y_coords = np.ravel([[line[0][1], line[0][3]] for line in lines])
	# 2. 进行直线拟合，得到多项式系数
	poly = np.polyfit(x_coords, y_coords, deg=1)
	# 3. 根据多项式系数，计算两个直线上的点，用于唯一确定这条直线
	point_min = (np.min(x_coords), np.polyval(poly, np.min(x_coords)))
	point_max = (np.max(x_coords), np.polyval(poly, np.max(x_coords)))
	return np.array([point_min, point_max], dtype=np.int)


print("left lane")
print(least_squares_fit(left_lines))
print("right lane")
print(least_squares_fit(right_lines))

直线绘制

API

绘制直线：cv2.line

img = cv2.imread('img.jpg', cv2.IMREAD_COLOR)
cv2.line(img, tuple(left_line[0], tuple(left_line[1]), color=(0, 255, 255), thickness=5)
cv2.line(img, tuple(right_line[0], tuple(left_line[1]), color=(0, 255, 255), thickness=5)

cv2.imshow('lane', img)
cv2.waitKey(0)

视频流读写

API

cv2.VideoCapture
- capture.read
cv2.VideoWriter
- writer.write

如果要用C++或python 处理视频流的话，建议使用ffmpeg

实现

def show_lane(color_img):
	"""
	在 color_img 上画出车道线
	:param color_img：彩色图，channels=3
	:return:
	"""
	edge_img = get_edge_img(color_img)
	mask_gray_img = roi_mask(edge_img)
	lines = get_lines(mask_gray_img)
	draw_lines(color_img, lines)
	return color_img


capture = cv2.VideoCapture('video.mp4')
# capture = cv2.VideoCapture(0)	# 读取当前设备

while True:
	ret, frame = capture.read()	# ret 表示当前图像是否关闭，frame 当前帧
	frame = show_lane(frame)
	cv2.imshow('frame', frame)
	cv2.waitKey(10)	# 可以表示当前视频帧率

以上是关于python+openCV (入门级)车道线检测学习笔记的主要内容，如果未能解决你的问题，请参考以下文章

从车道线检测入门OpenCV

基于Python+OpenCV车道线检测(直道和弯道)

车道线检测算法-Ultra-Fast-Lane-Detection

OpenCV实战案例——车道线识别

OpenCV 车道线提取

python+openCV (入门级)车道线检测 学习笔记

文章目录

前言

一、openCV安装

二、尝试使用cv2中库函数

1.读取图片

2.图片显示

3.延时/暂停

4.保存图片

5.清楚所有窗口

三、Canny边缘检测

1.高斯滤波

2.图片转换

3.边缘检测

四、ROI and mask

五、霍夫变换

六、离群值过滤

七、最小二乘法拟合

八、车道线标注

九、视频读写

1.打开视频

2.按帧读取视频

3.视频编码格式设置

4.写视频参数设置

十、其他

总结

附视频检测完整程序

opencv入门项目——车道线检测

文章目录

Canny 边缘检测

小程序

roi_mask

理论

实现

霍夫变换

基本原理

API

实现

离群值过滤

最小二乘拟合

API

实现

直线绘制

API

视频流读写

API

实现

python+openCV (入门级)车道线检测学习笔记