Python车道线检测模块

代码只是对大佬的代码进行了封装。

模型基本思路：

       基于Opencv库，采用基本的图形学算法来实现车道线的检测。首先将普通的RGB图片转化为灰度图片，通过高斯滤波器对图片进行平滑去噪，使用Canny边缘检测，指定ROI区域，过滤掉ROI区域以外的图片信息，采用霍夫转换找到车道线。

模型处理流程：

 

使用说明：

  在main方法中给出了接口的使用方法：

 Ld=Lane_Detection()     #实例化对象
 img = cv2.imread('../qwer.jpg') #cv2读入图片
 temp=Ld.predict(img,show_picture=True) 
 #使用模型预测车道线，img:图片，show_picture：是否展示图片，return:左右车道的坐标
 print("lane",temp)

模型的局限：

（1）车辆保持在同车道的高速路中行驶；（2）车道线清晰可见；（3）车辆前方一段距离内没有车辆。

  注：本模型只是一个基础版本，不适用复杂道路情景。具体商业算法还需对算法进一步优化。

代码部分：

'''
    :Author: "QingTai Jiang"
    :time:"2018/10/5"
    :keyword:"对道路决策算法进行封装"
'''
import numpy as np
import cv2
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")

class Lane_Detection(object):
    def __init__(self):
        self.blur_ksize = 5  # Gaussian blur kernel size
        self.canny_lthreshold = 50  # Canny edge detection low threshold
        self.canny_hthreshold = 150  # Canny edge detection high threshold
        self.rho = 1                # Hough transform parameters
        self.theta = np.pi / 180
        self.threshold = 15
        self.min_line_length = 40
        self.max_line_gap = 20
        self.left_lane_xy=0
        self.right_lane_xy=0
        self.image=0
    def show_image(self,lane_image):  # 展示图片
        print("show image")
        _, (ax1, ax) = plt.subplots(1, 2, figsize=(14, 14))
        ax.set_title('Lane_image')
        ax.axis('off')
        ax1.axis('off')
        ax1.set_title("Base_image")
        ax.imshow(lane_image[:, :, ::-1])
        ax1.imshow(self.image[:, :, ::-1])
        plt.show()

    def roi_mask(self,img, vertices):  # 指定ROI，指定区域
        mask = np.zeros_like(img)  # 全黑图像
        if len(img.shape) > 2:
            channel_count = img.shape[2]  # i.e. 3 or 4 depending on your image
            mask_color = (255,) * channel_count
        else:
            mask_color = 255
        cv2.fillPoly(mask, vertices, mask_color)  # 按照图像位置填充

        masked_img = cv2.bitwise_and(img, mask)  # 按位 与 1 and 1 = 1 ，白色是1  黑色是0
        # 拿到了车道的黑白图像
        return masked_img

    def draw_roi(self,img, vertices):
        cv2.polylines(img, vertices, True, [255, 0, 0], thickness=2)
    def draw_lines(self,img, lines, color=[255, 0, 0], thickness=2):
        for line in lines:
            for x1, y1, x2, y2 in line:
                cv2.line(img, (x1, y1), (x2, y2), color, thickness)

    def hough_lines(self,img, rho, theta, threshold, min_line_len, max_line_gap):
        '''
        image： 必须是二值图像，推荐使用canny边缘检测的结果图像；
        rho: 线段以像素为单位的距离精度，double类型的，推荐用1.0
        theta： 线段以弧度为单位的角度精度，推荐用numpy.pi/180
        threshod: 累加平面的阈值参数，int类型，超过设定阈值才被检测出线段，值越大，基本上意味着检出的线段越长，检出的线段个数越少。根据情况推荐先用100试试
        lines：这个参数的意义未知，发现不同的lines对结果没影响，但是不要忽略了它的存在
        minLineLength：线段以像素为单位的最小长度，根据应用场景设置
        maxLineGap：同一方向上两条线段判定为一条线段的最大允许间隔（断裂），超过了设定值，则把两条线段当成一条线段，值越大，允许线段上的断裂越大，越有可能检出潜在的直线段
        '''
        # 返回直线的数组坐标
        # 霍夫直线检测-HoughLinesP函数参数
        lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len,
                                maxLineGap=max_line_gap)
        # print("lines:", lines)
        line_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)
        self.draw_lanes(line_img, lines)

        return line_img

    def draw_lanes(self,img, lines, color=[255, 0, 0], thickness=8):
        '''
        现在我们要根据得到的线计算出左车道和右车道，一种可以采用的步骤是：
        根据斜率正负划分某条线属于左车道或右车道
        分别对左右车道线移除outlier：迭代计算各条线的斜率与斜率均值的差，逐一移除差值过大的线
        分别对左右车道线的顶点集合做linear regression，得到最终车道。
        '''
        # print("lines:", lines)
        left_lines, right_lines = [], []
        for line in lines:
            for x1, y1, x2, y2 in line:
                k = (y2 - y1) / (x2 - x1)
                if k < 0:
                    left_lines.append(line)
                else:
                    right_lines.append(line)
        if (len(left_lines) <= 0 or len(right_lines) <= 0):
            return img
        self.clean_lines(left_lines, 0.1)
        self.clean_lines(right_lines, 0.1)  # 清除异常点
        left_points = [(x1, y1) for line in left_lines for x1, y1, x2, y2 in line]

        left_points = left_points + [(x2, y2) for line in left_lines for x1, y1, x2, y2 in line]

        right_points = [(x1, y1) for line in right_lines for x1, y1, x2, y2 in line]

        right_points = right_points + [(x2, y2) for line in right_lines for x1, y1, x2, y2 in line]

        left_vtx = self.calc_lane_vertices(left_points, 325, img.shape[0])

        right_vtx = self.calc_lane_vertices(right_points, 325, img.shape[0])

        self.left_lane_xy=left_vtx
        self.right_lane_xy=right_vtx

        # 画直线
        cv2.line(img, left_vtx[0], left_vtx[1], color, thickness)
        cv2.line(img, right_vtx[0], right_vtx[1], color, thickness)

    def clean_lines(self,lines, threshold):
        slope = [(y2 - y1) / (x2 - x1) for line in lines for x1, y1, x2, y2 in line]
        while len(lines) > 0:
            mean = np.mean(slope)
            diff = [abs(s - mean) for s in slope]
            idx = np.argmax(diff)
            if diff[idx] > threshold:
                slope.pop(idx)
                lines.pop(idx)
            else:
                break

    def calc_lane_vertices(self,point_list, ymin, ymax):
        x = [p[0] for p in point_list]
        y = [p[1] for p in point_list]
        fit = np.polyfit(y, x, 1)
        fit_fn = np.poly1d(fit)
        xmin = int(fit_fn(ymin))
        xmax = int(fit_fn(ymax))

        return [(xmin, ymin), (xmax, ymax)]

    def predict(self,img,show_picture=True):
        '''
        :param img: 传入CV2读取的图片
        :return:    返回左右车道的坐标
        '''

        self.image=img
        roi_vtx = np.array([[(0, img.shape[0]), ((img.shape[1] * 20) // 40, (img.shape[0] * 2) // 3),
                             ((img.shape[1] * 22) // 44, (img.shape[0] * 2) // 3), (img.shape[1], img.shape[0])]])

        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)  # 彩色转化为灰度图

        blur_gray = cv2.GaussianBlur(gray, (self.blur_ksize, self.blur_ksize), 0, 0)  # 高斯模糊

        edges = cv2.Canny(blur_gray, self.canny_lthreshold, self.canny_hthreshold)  # 边缘检测

        roi_edges = self.roi_mask(edges, roi_vtx)  # 拿到车道黑白图像

        line_img = self.hough_lines(roi_edges, self.rho, self.theta, self.threshold, self.min_line_length, self.max_line_gap)

        res_img = cv2.addWeighted(img, 0.8, line_img, 1, 0)  # 两个图片叠加显示
        if show_picture:
            print("res_img")
            self.show_image(res_img)

        return self.right_lane_xy,self.left_lane_xy

if __name__=="__main__":
    Ld=Lane_Detection()
    img = cv2.imread('../qwer.jpg')
    temp=Ld.predict(img,show_picture=True)
    print("lane",temp)