【车道线检测】一、传统车道线检测：基于霍夫变换的车道线检测史诗级详细教 ...

1、定义图像显示函数

        起首定义一个函数，函数的作用是通过plt库显示两幅图，为后续实验做准备。该函数的主要功能是：

• 从指定路径加载图像
  
• 显示图像的基本信息
  
• 将图像从BGR格式转换为RGB格式
  
• 并在一个图形窗口中显示两幅图像进行对比
  

1. import numpy as np
2. import cv2
3. import matplotlib.pyplot as plt
4. import pandas as pd
5. import time
6. import warnings
8. warnings.filterwarnings("ignore")
10. def load_image(path):
11.     """
12.     从指定路径加载图像并返回。
14.     :param path: 图像文件的路径
15.     :return: 加载的图像
16.     """
17.     img = cv2.imread(path)
18.     if img is None:
19.         raise FileNotFoundError(f"Image not found at {path}")
20.     return img
22. def display_image_info(img, title="Image Info"):
23.     """
24.     打印图像的基本信息。
26.     :param img: 图像数据
27.     :param title: 打印信息的标题
28.     """
29.     print(f"{title}: Shape = {img.shape}")
31. def convert_to_rgb(img):
32.     """
33.     将图像从 BGR 格式转换为 RGB 格式。
35.     :param img: 输入图像
36.     :return: 转换后的图像
37.     """
38.     return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
41. def compare_images(img1, img2, titles=("Original Image", "Processed Image"), figsize=(16, 5)):
42.     """
43.     在一个图形窗口中显示两幅图像进行对比。
45.     :param img1: 第一幅图像
46.     :param img2: 第二幅图像
47.     :param titles: 两幅图像的标题
48.     :param figsize: 图形窗口的大小
49.     """
50.     fig, axes = plt.subplots(1, 2, figsize=figsize)
51.     fig.tight_layout()
53.     # 显示第一幅图像
54.     axes[0].imshow(convert_to_rgb(img1))
55.     axes[0].set_title(titles[0])
56.     axes[0].axis('off')
58.     # 显示第二幅图像
59.     axes[1].imshow(convert_to_rgb(img2))
60.     axes[1].set_title(titles[1])
61.     axes[1].axis('off')
63.     plt.show()
65. # 主程序
66. if __name__ == "__main__":
67.     # 加载图像
68.     image_path = 'dataset/test3.jpg'
69.     img = load_image(image_path)
70.    
71.     # 显示图像信息
72.     display_image_info(img)
73.    
74.     # 对比显示原始图像和处理后的图像
75.     compare_images(img, img, titles=("Original Image", "RGB Image"))

复制代码

• 运行效果如下：(原图和RGB图)
  

2、将图像转换为灰度图

• 将图像转换为灰度图：
  

1. #将图像转换为灰度图
2. def convert_to_gray(img):
3.     temp = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
4.     return cv2.cvtColor(temp,cv2.COLOR_BGR2RGB)
5. gray_img = convert_to_gray(img)
6. #对比显示原始图像和灰度图像
7. compare_images(img, gray_img, titles=("Original Image", "Grayscale Image"))

复制代码

• 运行效果如下：(原图和灰度图)
  

3、高斯模糊

               高斯模糊是一种图像处置处罚效果，通常用于减少图像噪声以及降低细节层次。它是一种平滑和淡化图像部门的技术，通常用于减少噪声或为图像的前景添加焦点。高斯模糊如下：
   

1. #高斯模糊
2. def gaussian_blur(image, kernel_size):
3.     """
4.     对图像进行高斯模糊处理。
6.     :param image: 输入图像
7.     :param kernel_size: 高斯核的大小，必须是奇数
8.     :return: 高斯模糊后的图像
9.     """
10.     if kernel_size % 2 == 0:
11.         raise ValueError("Kernel size must be an odd number.")
12.     return cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)
14. # 对灰度图像进行高斯模糊处理
15. gauss_img = gaussian_blur(gray_img, 5)
17. # 对比显示灰度图像和高斯模糊后的图像
18. compare_images(gray_img, gauss_img, titles=("Grayscale Image", "Gaussian Blurred Image"))

复制代码

• 运行效果如下：（灰度图和高斯处置处罚效果图）
  

4、边沿检测

               边沿检测是图形图像处置处罚、盘算机视觉和呆板视觉中的一个基本工具，通常用于特征提取和特征检测，旨在检测一张数字图像中有明显变化的边沿大概不一连的区域，在一维空间中，类似的操纵被称作步长检测（step detection）。边沿是一幅图像中不同屈原之间的边界限，通常一个边沿图像是一个二值图像。边沿检测的目标是捕捉亮度急剧变化的区域，而这些区域通常是我们关注的。
    4.1 灰度图像直方图

• 绘制灰度图像的像素值分布直方图：
  

1. #灰度图直方图
2. plt.hist(gauss_img.ravel(),256,[0,256])
3. plt.title('hist of gray pixel')
4. plt.show()

复制代码

•  运行效果如下图：
  

从图像的灰度图像素值分布直方图可以看出像素值主要分布在110到140之间。 
4.2 边沿检测

        图像边沿检测，从上述的图像灰度图的像素值的分布值中我们知道像素值的分布峰值在110-140之间，故canny(gauss_img,110,140)，边沿检测如下：

1. #边缘检测
2. def canny(image,low_threshold,high_threshold):
3.     """
4.     功能: 使用Canny算法进行边缘检测。
5.     参数:
6.         image: 输入图像，通常应该是灰度图像。
7.         low_threshold: 低阈值，用于检测弱边缘。
8.         high_threshold: 高阈值，用于检测强边缘。
9.     返回: 边缘检测后的图像。
10.     """
11.     return cv2.Canny(image,low_threshold,high_threshold)
12. cannyd_img = canny(gauss_img,110,140)
13. compare_images(gauss_img,cannyd_img, titles=("Grayscale Image", "Canny Image"))

复制代码

• 运行效果如下：
  

5、提取感爱好区域(ROI)

5.1 原图提取ROI

• 代码先容：
  

        下列代码实现了一个功能，该功能可以基于给定的多边形顶点来提取图像中的特定区域。这个过程包括创建一个与输入图像相同大小的掩模，然后在这个掩模上添补多边形区域，并使用这个掩模与原始图像进行按位与操纵，从而只保留多边形区域内的图像部门。

• 封装了一个region_of_interest 函数:
  
  
  
  • 创建一个与输入图像相同大小的黑色掩模。
    
  • 根据图像的通道数确定掩模的颜色。
    
  • 添补多边形区域为白色，以创建掩模。
    
  • 将原图像与掩模进行按位与操纵，以保留爱好区域。
    
  
  

• ROI区域实现如下：
  

1. #生成mask掩膜，提取ROI
2. #ROI即感兴趣区域，英文：Region of interest
4. def region_of_interest(image: np.ndarray, vertices: np.ndarray) -> np.ndarray:
5.     """
6.     应用图像掩模以保留由顶点定义的兴趣区域。
7.    
8.     参数:
9.     :param image: 输入图像（numpy数组）。
10.     :param vertices: 定义兴趣区域的多边形顶点数组。
11.     :return: 应用了掩模的图像。
12.     """
13.     # 创建与输入图像相同大小的黑色掩模
14.     mask = np.zeros_like(image)
15.    
16.     # 根据图像的通道数确定掩模的颜色
17.     ignore_mask_color = (255,) * image.shape[2] if len(image.shape) > 2 else 255
18.    
19.     # 填充多边形区域为白色，以创建掩模
20.     cv2.fillPoly(mask, vertices, ignore_mask_color)
21.    
22.     # 将原图像与掩模进行按位与操作，以保留兴趣区域
23.     masked_image = cv2.bitwise_and(image, mask)
24.    
25.     return masked_image
27. # 获取图像尺寸
28. imshape = img.shape
30. # 设置掩膜区域
31. temp_v = np.array([[(0, 350), (350, 225), (530, 245), (800, 355), (950, 1000), (0, 700)]], dtype=np.int32)
33. # 调用函数裁剪图像
34. crop_img = region_of_interest(img, temp_v)
36. # 显示对比图
37. compare_images(img,crop_img,titles=("Grayscale Image", "ROI Image"))

复制代码

•  运行效果如下：
  

5.2 边沿检测后提取ROI

• 对边沿检测后的图像进行提取ROI，如下：
  

1. crop_mask = region_of_interest(cannyd_img,temp_v)
2. compare_images(cannyd_img,crop_mask,titles=("Canny Image", "ROI Canny Image"))

复制代码

• 运行效果如下：
  

6、基于霍夫变换检测直线

6.1 什么是霍夫变换？

• 定义：
  

               霍夫变换(Hough Transform)是图像处置处罚中的一种特征提取技术，它通过一种投票算法检测具有特定外形的物体。Hough变换是图像处置处罚中从图像中辨认几何外形的基本方法之一。Hough变换的基本原理在于使用点与线的对偶性，将原始图像空间的给定的曲线通过曲线表达情势变为参数空间的一个点。如许就把原始图像中给定曲线的检测问题转化为寻找参数空间中的峰值问题。也即把检测整体特性转化为检测局部特性。比如直线、椭圆、圆、弧线等。
                    原则上霍夫变换可以检测任何外形，但复杂的外形需要的参数就多，霍夫空间的维数就多，因此在程序实现上所需的内存空间以及运行服从上都不利于把标准霍夫变换应用于实际复杂图形的检测中。霍夫梯度法是霍夫变换的改进（圆检测），它的目标是减小霍夫空间的维度，提高服从。
     
     直线检测原理：将要检测的对象转到霍夫空间中，使用累加器找到最优解，即为所求直线。
     （注：检测前要对图像二值化处置处罚）
     6.2 霍夫变换实现

                   下列代码定义了两个函数 hough_lines 和 lsd_lines，分别用于使用霍夫变换和LSD算法检测图像中的直线，并使用了一个装饰器 timed_function 来测量这两个函数的实行时间。

• 实现如下:
  

1. def timed_function(func):
2.     """装饰器，用于测量函数执行时间"""
3.     def wrapper(*args, **kwargs):
4.         start = time.time()
5.         result = func(*args, **kwargs)
6.         end = time.time() - start
7.         print(f"{func.__name__} took {end:.4f}s")
8.         return result
9.     return wrapper
11. @timed_function
12. def hough_lines(img: np.ndarray, rho: float, theta: float, threshold: int, min_line_length: int, max_line_gap: int) -> np.ndarray:
13.     """
14.     使用霍夫变换检测图像中的直线。
15.    
16.     参数:
17.     :param img: 输入图像（边缘检测后的二值图像）。
18.     :param rho: 线段以像素为单位的距离精度。
19.     :param theta: 像素以弧度为单位的角度精度。
20.     :param threshold: 霍夫平面累加的阈值。
21.     :param min_line_length: 线段最小长度（像素级）。
22.     :param max_line_gap: 最大允许断裂长度。
23.     :return: 检测到的直线数组。
24.     """
25.     lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), min_line_length, max_line_gap)
26.     return lines
28. # 参数设置
29. rho = 1
30. theta = np.pi / 180
31. hof_threshold = 20
32. min_line_len = 30
33. max_line_gap = 100
35. # 调用函数
36. lines_hough = hough_lines(crop_mask, rho, theta, hof_threshold, min_line_len, max_line_gap)

复制代码

• 上述参数先容：
  
  
  • rho: 线段以像素为单元的距离精度。
    
  • theta: 像素以弧度为单元的角度精度。
    
  • hof_threshold: 霍夫平面累加的阈值。
    
  • min_line_len: 线段最小长度（像素级）。
    
  • max_line_gap: 最大允许断裂长度。
    
  
  
• 代码运行效果如下：
  

7、车道线检测并盘算斜率

• 在图像上绘制检测到的车道线，并显示每条线的斜率：
  

1. #车道线斜率显示
2. def draw_lines(image: np.ndarray, lines: np.ndarray) -> np.ndarray:
3.     """
4.     在图像上绘制检测到的车道线，并显示每条线的斜率。
5.    
6.     参数:
7.     :param image: 输入图像。
8.     :param lines: 检测到的直线数组。
9.     :return: 绘制了车道线的图像。
10.     """
11.     for line in lines:
12.         for x1, y1, x2, y2 in line:
13.             # 计算直线的斜率
14.             fit = np.polyfit((x1, x2), (y1, y2), deg=1)
15.             slope = fit[0]
16.             slope_str = f"{slope:.2f}"  # 格式化斜率字符串
17.             
18.             # 绘制直线
19.             cv2.line(image, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 10)
20.             
21.             # 在终点附近绘制斜率文本
22.             cv2.putText(image, slope_str, (int(x2), int(y2)), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (255, 255, 255), 2)
23.    
24.     return image
26. # 调用函数
27. lined_image = draw_lines(img.copy(),lines_hough)
29. # 显示对比图
30. compare_images(img, lined_image,titles=("Original Image", "Lane line slope Image"))

复制代码

• 运行效果如下：
  

8、盘算车道线均匀斜率和截距

• 盘算了左右车道线和中央线的均匀斜率和截距：
  

2. def draw_lines_detection(image: np.ndarray, lines: np.ndarray) -> tuple:
3.     """
4.     在图像上绘制检测到的车道线，并计算左右车道线和中心线的平均斜率和截距。
5.    
6.     参数:
7.     :param image: 输入图像。
8.     :param lines: 检测到的直线数组。
9.     :return: 绘制了车道线的图像以及左右车道线和中心线的平均斜率和截距。
10.     """
11.     middle_x = image.shape[1] // 2  # 图像的中点
12.     left_slopes = []
13.     right_slopes = []
14.     center_slopes = []
16.     left_biases = []
17.     right_biases = []
18.     center_biases = []
20.     for line in lines:
21.         for x1, y1, x2, y2 in line:
22.             fit = np.polyfit((x1, x2), (y1, y2), deg=1)
23.             slope = fit[0]
24.             bias = fit[1]
26.             if -0.41 < slope < -0.30:  # 左边线
27.                 cv2.line(image, (x1, y1), (x2, y2), (0, 255, 0), 10)
28.                 left_slopes.append(slope)
29.                 left_biases.append(bias)
30.             elif 0.38 < slope < 0.42:  # 右边线
31.                 cv2.line(image, (x1, y1), (x2, y2), (0, 0, 255), 10)
32.                 right_slopes.append(slope)
33.                 right_biases.append(bias)
34.             elif slope > 1:  # 中心线
35.                 cv2.line(image, (x1, y1), (x2, y2), (255, 0, 0), 10)
36.                 center_slopes.append(slope)
37.                 center_biases.append(bias)
39.     # 计算平均值
40.     left_slope = np.mean(left_slopes) if left_slopes else 0
41.     left_bias = np.mean(left_biases) if left_biases else 0
42.     right_slope = np.mean(right_slopes) if right_slopes else 0
43.     right_bias = np.mean(right_biases) if right_biases else 0
44.     center_slope = np.mean(center_slopes) if center_slopes else 0
45.     center_bias = np.mean(center_biases) if center_biases else 0
47.     return image, left_slope, left_bias, right_slope, right_bias, center_slope, center_bias
49. # 调用函数
50. lined_image, left_slope, left_bias, right_slope, right_bias, center_slope, center_bias = draw_lines_detection(img.copy(), lines_hough)
52. # 显示对比图
53. compare_images(img, lined_image,titles=("Original Image", "Lane markings detection Image"))

复制代码

• 运行效果如下：
  

 上述代码先容：

• 功能: 在图像上绘制检测到的车道线，并盘算左右车道线和中央线的均匀斜率和截距。
  
• 参数:
  
  
  
  • image: 输入图像。
    
  • lines: 检测到的直线数组。
    
  
  
• 返回: 绘制了车道线的图像以及左右车道线和中央线的均匀斜率和截距。
  
• 步调:
  
  
  • 盘算图像的中点。
    
  • 初始化存储斜率和截距的列表。
    
  • 遍历每条直线，盘算斜率和截距。
    
  • 根据斜率范围判定直线属于左边线、右边线还是中央线，并分别绘制不同颜色的直线。
    
  • 将斜率和截距添加到相应的列表中。
    
  • 盘算每个类别的均匀斜率和截距。
    
  • 返回绘制了车道线的图像和盘算结果。
    
  
  

9、绘制每一条车道线

• 在图像上绘制左右车道线和中央线：
  

1. def draw_all_line(img, slope, bias, color, y2=230):
2.     # 计算起点
3.     x1 = 0 if slope == 'left' else img.shape[1] if slope == 'right' else int((img.shape[0] - bias) / slope)
4.     y1 = int(slope * x1 + bias) if isinstance(slope, (int, float)) else img.shape[0]
5.    
6.     # 计算终点
7.     x2 = int((y2 - bias) / slope) if isinstance(slope, (int, float)) else x1
8.    
9.     # 绘制线条
10.     line_img = cv2.line(img.copy(), (x1, y1), (x2, y2), color, 10)
11.    
12.     return line_img
14. # 左边线
15. left_lines = draw_all_line(img, left_slope, left_bias, (0, 255, 0))
16. compare_images(img, left_lines,titles=("Original Image", "Left Lane Image"))
18. # 右边线
19. right_lines = draw_all_line(img, right_slope, right_bias, (0, 0, 255))
20. compare_images(img, right_lines,titles=("Original Image", "Right Lane Image"))
22. # 中线
23. center_lines = draw_all_line(img, center_slope, center_bias, (255, 0, 0))

复制代码

• 运行效果如下：
  

10、图像融合--绘制最终的车道线

• 在一个空缺图像上绘制左右车道线和中央线，并将这些线条与原图像进行融合：
  

1. import numpy as np
2. import cv2
4. def draw_line(blank, slope, bias, color, y2=230):
5.     # 计算起点
6.     if slope == 'left':
7.         x1 = 0
8.         y1 = int(slope * x1 + bias)
9.     elif slope == 'right':
10.         x1 = blank.shape[1]
11.         y1 = int(slope * x1 + bias)
12.     else:
13.         y1 = blank.shape[0]
14.         x1 = int((y1 - bias) / slope)
15.    
16.     # 计算终点
17.     x2 = int((y2 - bias) / slope) if slope != 'left' and slope != 'right' else x1
18.    
19.     # 绘制线条
20.     cv2.line(blank, (x1, y1), (x2, y2), color, 20)
22. def draw_lines_and_fuse(img, left_slope, left_bias, right_slope, right_bias, center_slope, center_bias):
23.     # 创建空白图像
24.     blank = np.zeros_like(img)
25.    
26.     # 绘制左车道线
27.     draw_line(blank, left_slope, left_bias, (0, 255, 0))
28.    
29.     # 绘制右车道线
30.     draw_line(blank, right_slope, right_bias, (0, 0, 255))
31.    
32.     # 绘制中线
33.     draw_line(blank, center_slope, center_bias, (255, 0, 0))
34.    
35.     # 图像融合
36.     fusion = cv2.addWeighted(img, 0.8, blank, 1, 0)
37.    
38.     return fusion
40. # 示例调用
41. fusion = draw_lines_and_fuse(img, left_slope, left_bias, right_slope, right_bias, center_slope, center_bias)
42. compare_images(img, fusion,titles=("Original Image", "Image blending--Lane markings detection results"))

复制代码

• 运行效果如下：
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。