精华内容
下载资源
问答
  • 车道线检测 ····在参加udacity的课程后,对于车道线有了一些直观的认识,后来在实验室学习和外出实习过程中,也接触过不少车道线方面的检测工作,这边将对这些日子里的工作做一个总结。 ····这也是我写的第...

    车道线检测

    ····在参加udacity的课程后,对于车道线有了一些直观的认识,后来在实验室学习和外出实习过程中,也接触过不少车道线方面的检测工作,这边将对这些日子里的工作做一个总结。
    ····这也是我写的第一篇博客(以前都习惯整理在自己电脑里面,但想想还是没有blog绘声绘色)。
    ····车道线检测,从易到难:单直线车道检测–>单弯道车道检测–>多直线车道检测–>多弯道车道检测(事实上能检测弯道就能够检测直道,相当于曲率半径极大的弯道)
    ····我更希望用例子去说明,多按图说话。本篇分三个内容:

    ···· 1.讲解Udacity的CarND-LaneLines-P1-master项目
    ···· 2.讲解Udacity的CarND-Advanced-Lane-Lines-master项目
    ···· 3.讲解我在这基础上改进的multi-lane-lines-detection项目

    CarND-LaneLines-P1-master

    ····只能针对直线车道检测,结果稳定,实时性高,但波动大,鲁棒性差,有待改进。
    车道线
    ····如图所示,为项目结果图,从单车道检测而言,效果不错而且实时性高,那么具体是怎么做的呢!
    ····主要思路:对输入图像通过灰度化、高斯滤波、canny边缘检测;再框选出感兴趣区域,对感兴趣区域内的二值化点集进行hough变换,得到目标直线集;对直线集进行分类、合并得到稳定输出结果。

    思路讲解

    ····我们通过一帧图片来说明处理过程。
    在这里插入图片描述
    ····如图[image]所示为图像原图,此时为(540x860x3)的数组矩阵,即3层R,G,B通道色彩数据,canny算子变换只关注色值,即(540x860)矩阵中的数值,同一张图片,三通道色值差异不大,通过灰度化,压缩3通道为单通道,减少数据量,使用函数cv2.cvtColor(image, cv2.COLOR_RGB2GRAY),通常效果较好的是加权平均灰度化,其他具体处理方式见1,里面通过图例,简单直观说明其原理和方法。;
    ····对比[gray]、[blur_gray],明显觉得[blur]更模糊一些,这是由于[blur]进行了高斯滤波,设计一个计算核,大小为3x3或者5x5,类似加权平均的方法,权值满足正态分布,遍历图片,去掉可能存在的椒盐噪声,为hough变换做好准备,这里使用cv2.GaussianBlur(gray, (kernel_size, kernel_size), 0),实现高斯滤波,kernel_size就是核的大小,一般为基数,有疑惑的童鞋请见转载2,里面通过图例,直观说明常用图像处理滤波器;
    在这里插入图片描述
    ····此时,我们转移注意力到图[edges],[edges]通过边缘检测得到,边缘检测算子常见的有Canny,Roberts,Prewitt,简而言之,通过算子基于差分原理得到一个数值,代表区别度大小,再基于两个阈值对图像进行滤波,去除过多噪点,得到high_threimg和low_threimg,由于high_threshold阈值更大,必然去掉了部分有效特征,再与low_threimg图像进行比对、拼接,得到稳定的图像输出结果,这里使用cv2.Canny(blur_gray, low_threshold, high_threshold),通过high_threshold和low_threshold对区别度进行限制,实现理想的二值化图[edges],这里的threshold皆为经验调参值,关于Canny的详细见转载3
    关于其他算子综述见4.
    在这里插入图片描述
    ····我们可以看到对于一张图片的二值化处理,除了我们需要的车道信息,还会有周围环境特征,如天空、山、周边荒草环境等,为了提高算法鲁棒性,通过框选感兴趣区域,是一个不错的选择,[masked_edges]即为结果。这里我们只针对单车道线检测,划出图像中关于自身车位的前方及左右半条车道范围延伸至灭点,如上图所示,如针对多车道线测,那在框选时需要更加慎重,除了地平线以上剔除外,地平线以下根据拍摄质量好坏(像素较低时不足以得到一个稳定结果)和有效车道数设定(不要求全检测,只检测左右三车道,更合适用于实车运行),所用函数见下文代码解析;
    ····之后就是基于hough变换提取出若干线段,把二值化后的像素坐标点集(XY)转化到栅格化的极坐标(rθ),基于投票选举法,统计得到若干条概率最高的直线,针对这些直线进行合并和剔除,得到最终车道线,如图[line_image],完工!所用函数见下文代码解析,关于hough变换的具体细节见转载5,里面通过图例,直观说明常用图像处理滤波器(转载自其他作者,如有侵权请私戳)

    代码讲解

    ····上面讲解了思路,这里说明一下代码吧。主要是基于每个函数进行讲解,最后再说明优化方向。
    详见:https://github.com/wisdom-bob/CarND-LaneLines-P1-master

    # importing some useful packages
    import matplotlib.pyplot as plt
    import matplotlib.image as mpimg
    import numpy as np
    import math
    import cv2
    
    # define some functions
    def grayscale(img):
        return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    #     return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # use BGR2GRAY if you read an image with cv2.imread()
        
    def canny(img, low_threshold, high_threshold):
    	#  Image Binarization with canny operator
        return cv2.Canny(img, low_threshold, high_threshold)
    
    def gaussian_blur(img, kernel_size):
    	#	gaussian filter by (kernel_size,kernel_size) operator
        return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)
    
    def region_of_interest(img, vertices):
        #defining a blank mask to start with
        mask = np.zeros_like(img)   
        
        #defining a 3 channel or 1 channel color to fill the mask, depending on the input image
        if len(img.shape) > 2:
            channel_count = img.shape[2]  # i.e. 3 or 4 depending on your image
            ignore_mask_color = (255,) * channel_count
        else:
            ignore_mask_color = 255
            
        #filling pixels inside the polygon defined by "vertices" with the fill color    
        cv2.fillPoly(mask, vertices, ignore_mask_color)
        
        #returning the image only where mask pixels are nonzero
        masked_image = cv2.bitwise_and(img, mask)
        return masked_image
    
    def draw_lines(img, lines, color=[255, 0, 0], thickness=8):
        for line in lines:
            for x1,y1,x2,y2 in line:
                cv2.line(img, (x1, y1), (x2, y2), color, thickness)
    
    def Ltopend(arr,imshape):
    	#	return the top point(x0,y0) and end point(x1,y1) of the line
        Arr = np.concatenate(arr, axis=0)
        k = sum(Arr[:,1]-Arr[:,3])/sum(Arr[:,0]-Arr[:,2])
        b = Arr[0][1]-k*Arr[0][0]
        
        x0 = int((imshape[0]-b)//k)
        y0 = imshape[0]
        for i in Arr:
            if i[3] == min(min(Arr[:,1]),min(Arr[:,3])):
                x1,y1 = i[3],i[2]
            elif i[1] == min(min(Arr[:,1]),min(Arr[:,3])):
                x1,y1 = i[1],i[0]
        return ((x0,y0),(y1,x1))
    
    def draw_lines2(img, lines, color=[255, 0, 0], thickness=14):
    	# updated draw_lines function
        le,ri= [],[]
        for line in lines:
            for x1,y1,x2,y2 in line:
                if (y2-y1)/(x2-x1)<0:
                    le.append(line)
                else:
                    ri.append(line)
        le = np.array(le)
        ri = np.array(ri)
        points = Ltopend(le,img.shape)
        cv2.line(img, points[0], points[1], color, thickness)
        points = Ltopend(ri,img.shape)
        cv2.line(img, points[0], points[1], color, thickness)    
                
    def hough_lines(img, rho, theta, threshold, min_line_len, max_line_gap,flag=0):
    	#	according to the HoughLinesP to get the lines, then draw them
        lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap)
        line_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)
        if flag:
            draw_lines2(line_img, lines, img.shape)
        else:
            draw_lines(line_img, lines)
        return line_img
    
    def weighted_img(img, initial_img, α=0.8, β=1., γ=0.):
    	#	image blending
        return cv2.addWeighted(initial_img, α, img, β, γ)
    

    ····通过以上函数,我们设置了若干个函数接口用于接入灰度化、高斯滤波、canny二值化、hough变换等,那么基于以上函数,我们可以自己先尝试得到图像处理结果(上图的结果)。

    def showimg(subplace, title, _img):
    	#	design a subplot_imshow funciton
        plt.subplot(*subplace)
        plt.title(title)
        if len(_img.shape) == 3:
            plt.imshow(_img)
        else:
            plt.imshow(_img, cmap='gray')
    
    #	from loca upload some images
    names = []
    for file in os.listdir("test_images/"):
        names.append(str(file[:file.rfind('.')]))
        
    #	image->grayscale->gaussian_blur->canny->edges
    name = names[1]
    image = files[name]
    gray = grayscale(image)
    blur_gray = gaussian_blur(gray,7)
    edges = canny(blur_gray, 50, 150)
    
    #	Next we'll create a masked edges image using cv2.fillPoly() to get the region of interest
    mask = np.zeros_like(edges)   
    ignore_mask_color = 255   
    imshape = image.shape
    
    vertices = np.array([[(0,imshape[0]),(410, 330), (550, 330), (imshape[1],imshape[0])]], dtype=np.int32)
    masked_edges = region_of_interest(edges,vertices)
    
    #	Define the Hough transform parameters
    rho = 1                             # distance resolution in pixels of the Hough grid
    theta = np.pi/180                   # angular resolution in radians of the Hough grid
    threshold = 15                      # minimum number of votes (intersections in Hough grid cell)
    min_line_length = 25                 # minimum number of pixels making up a line
    max_line_gap = 25                   # maximum gap in pixels between connectable line segments
    line_image = np.copy(image)*0       # creating a blank to draw lines on
    
    #	Run Hough on edge detected image
    line_image = hough_lines(masked_edges, rho, theta, threshold, min_line_length, max_line_gap,flag=1)
    
    #	Create the combined image, show and save it
    color_edges = np.dstack((edges, edges, edges)) 
    finalimg = weighted_img(line_image,image)
    # plt.savefig("out"+name)
    
    #	debug with images to show
    plt.figure(figsize=[16, 9])
    for i, imgname in enumerate(['image', 'gray', 'blur_gray', 'edges', 'masked_edges','line_image']):
        showimg((2, 3, i+1), imgname, eval(imgname))
    

    ····在此基础之上,我们已经基本摸清楚了这些函数的具体用途和使用效果,那么我们可以基于上段函数来构建一个function,写定各参数,实现面向实时的单车道线检测处理。

    def process_image(image, ignore_mask_color = 255, rho = 1, theta = np.pi/180, threshold = 15, min_line_length = 25,max_line_gap = 25):
    	# gray
        gray = grayscale(image)
        
        # blur_gray
        blur_gray = gaussian_blur(gray,7)
        
        # edges
        edges = canny(blur_gray, 50, 150) 
        
        # region-of-interest
        imshape = image.shape
        mask = np.zeros_like(edges)   
        vertices = np.array([[(0,imshape[0]),(410, 330), (550, 330), (imshape[1],imshape[0])]], dtype=np.int32)
        masked_edges = region_of_interest(edges,vertices)
    
    	# creating a blank to draw lines on
        line_image = np.copy(image)*0       
    
        # Run Hough on edge detected image
        line_image = hough_lines(masked_edges, rho, theta, threshold, min_line_length, max_line_gap,flag=0)
    
        # Create the combined image, show and save it
        color_edges = np.dstack((edges, edges, edges)) 
        finalimg = weighted_img(line_image,image)
        return finalimg
    

    ····此时接入视频,查看结果.

    # Import everything needed to edit/save/watch video clips
    from moviepy.editor import VideoFileClip
    from IPython.display import HTML
    
    white_output = 'test_videos_output/solidWhiteRight.mp4'
    clip1 = VideoFileClip("test_videos/solidWhiteRight.mp4")
    white_clip = clip1.fl_image(process_image) #NOTE: this function expects color images!!
    %time white_clip.write_videofile(white_output, audio=False)
    

    在这里插入图片描述

    总结和拓展

    ····至此基于hough的单车道线检测已经完成了,无需gpu,只在cpu上跑可以达到40帧/s,满足实时性要求,算是非常好的结果,而且车道线检测结果非常稳定,只是偶尔会有错帧,而且hough变换只能基于直线来进行,弯道检测必须用其他方法。
    ····从优化角度去考虑,至少可以再加个平滑器,这样图像效果更棒,提高鲁棒性,不易受偶尔的错帧影响;无法应对复杂场景,可以考虑增加灭点特征,可以减少部分错误结果,提高算法鲁棒性;可以考虑增加跟踪器,提高算法结果的可靠性。
    ····快去试试吧~~

    如有侵权,请私戳~~感谢。


    1. https://www.cnblogs.com/finlay/p/3665302.html ↩︎

    2. https://blog.csdn.net/eastmount/article/details/82216380 ↩︎

    3. https://www.cnblogs.com/techyan1990/p/7291771.html ↩︎

    4. https://www.cnblogs.com/wlzy/p/7283579.html ↩︎

    5. https://blog.csdn.net/yuyuntan/article/details/80141392 ↩︎

    展开全文
  • 高级车道线检测

    千次阅读 多人点赞 2018-10-03 20:34:43
    基于图像处理相关技术的高级车道线检测(可适用于弯道,车道线颜色不固定,路面阴影,亮光) pipeline: 1.校准摄像头的畸变,使拍摄照片能够较完整的反映3D世界的情况 2.对每一帧图片做透视转换(perspective ...

    基于图像处理相关技术的高级车道线检测(可适用于弯道,车道线颜色不固定,路面阴影,亮光)
    pipeline:
    1.校准摄像头的畸变,使拍摄照片能够较完整的反映3D世界的情况
    2.对每一帧图片做透视转换(perspective transform),将摄像头的照片转换到鸟瞰图视角(图片见正文),方便计算车道线曲率,从而控制车辆运动
    3.对鸟瞰图二值化,通过二值的像素点进一步区分左右两条车道线,从而拟合出车道线曲线
    4.用滑窗的方法检测第一帧的车道线像素点,然后拟合车道线曲线
    5.从第一帧的曲线周围寻找接下来的车道线像素点,然后拟合车道线曲线,这样可以节约计算资源,加快检测速度
    6.有了车道线曲线方程之后,可以计算斜率和车道线偏离中心的位置

    正文
    1.校准摄像头畸变
    摄像头畸变主要分两种,径向畸变和切向畸变,径向畸变是由于光线经过摄像机的镜头时,边缘的光线会更多或更少的弯曲,所以边缘的物体成像时会有畸变。切向畸变主要是由于镜头和成像胶卷或传感器不平行导致的。
    关于由5个参数矫正畸变,k1-k5,畸变越严重,所需参数越多,径向畸变矫正公式如下:在这里插入图片描述
    切向畸变矫正公式如下:
    在这里插入图片描述
    其中x,y为原图任一点,x,y(corrected)为其对应的没有畸变的图像上的坐标,r为点到中心的距离,K1,K2,K3为径向畸变参数,P1,P2为切向畸变参数,矫正参数由opencv的API来获得。这里用棋盘图的原因是计算点坐标相对容易,一般计算要多拍一些棋盘图在不同角度的照片,找到每一张棋盘图的角点坐标(图中的全部(x,y)和(x,y)(corrected)坐标),和其对应的未畸变的角点坐标,然后计算矫正参数进行矫正。

    #创建objpoints和imgpoints来接收来自无畸变图片和相机拍摄畸变图片的角点,存储多张图片角点增加矫正的准确率。
    def calibrate_camera(nx,ny):
        objp = np.zeros((nx*ny,3), np.float32)
        objp[:,:2] = np.mgrid[0:nx,0:ny].T.reshape(-1,2)
    
        objpoints = []
        imgpoints = []
    
        images = glob.glob('camera_cal/calibration*.jpg')
    
        for idx, fname in enumerate(images):
            #convert image to gray that the 'cv2.findChessboardCorners' needed
            img = mpimg.imread(fname)
            gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
            #Finding chessboard corners (for an 9×️6 board)
            ret, corners = cv2.findChessboardCorners(gray, (nx,ny), None)
    
            if ret == True:
                objpoints.append(objp)
                imgpoints.append(corners)
                #mtx represents 3D to 2D transformation, dist represents undistortion coef, rvecs the spin of camera
                #and tvecs the offset(偏移量)of the camera in the real world.
        return objpoints, imgpoints
    

    有了目标点和图像点的角点信息之后,利用opencv的API自动计算矫正系数来矫正每一帧图片,返回值是无畸变图像,图1为矫正前图像,图2为矫正后图像。

    def undistort_image(img):
        objectpoints, imagepoints = calibrate_camera(9,6)
        img_size = img.shape[1::-1]
        #get the distortion coef and other parameters
        ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objectpoints, imagepoints, img_size, None, None)
        #Undistort a image
        dst = cv2.undistort(img, mtx, dist, None, mtx)
        return dst
    

    矫正前

    矫正后

    接着就是为了计算曲率,将摄像头的视角进行转换,转换的结果最好是转换成从上向下的视角,造成摄像机从空中垂直拍摄车道线的效果,使用转换前图片任意多边形的边界点和转换以后多边形的边界点作为输入,调用opencv的cv2.getPerspectiveTransform函数可以返回转换的矩阵M,Minv是反转换矩阵,warped就是转换后车道线鸟瞰图。

    def perspective_transform(img):
        # Vertices extracted manually for performing a perspective transform
        leftupperpoint = [568, 470]
        rightupperpoint = [717, 470]
        leftlowerpoint = [260, 680]
        rightlowerpoint = [1043, 680]
    
        src = np.float32([leftupperpoint, leftlowerpoint, rightupperpoint, rightlowerpoint])
        dst = np.float32([[200, 0], [200, 680], [1000, 0], [1000, 680]])
    
        img_size = img.shape[1::-1]
        #Compute the perspective transform, M, given source and destination points
        M = cv2.getPerspectiveTransform(src, dst)
        #Compute the inverse perspective transform
        Minv = cv2.getPerspectiveTransform(dst, src)
        #Warp an image using the perspective transform, M
        warped = cv2.warpPerspective(img, M, img_size, flags=cv2.INTER_LINEAR)
        return M, Minv, warpeddef perspective_transform(img):
       
    

    在这里插入图片描述
    有了鸟瞰图,还是要让程序自己辨别左右两条车道线,车道线在图像上是两条垂直线,可以用边缘检测的方法检测出,关于Sobel边缘检测,用sobel算子在x方向求导数可以很好的检测出垂直的车道线,但是为了让车道线检测效果更鲁棒,这里还需要结合一些图像颜色空间的知识,实验表明,HLS颜色中的S(饱和度)空间对阴影,光照的结果很鲁棒,因为饱和度通常反应物体颜色的鲜艳程度,与物体颜色及颜色亮暗无关,所以采用x方向的sobel边缘检测和饱和度阈值结合的方法可以使车道线检测结果更鲁棒
    在这里插入图片描述

    def pipeline(img, s_thresh=(170, 255), sx_thresh=(20, 100)):
        img = np.copy(img)
        # Convert to HLS color space and separate the V channel
        hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)
        l_channel = hls[:,:,1]
        s_channel = hls[:,:,2]
        # Sobel x
        sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0) # Take the derivative in x
        abs_sobelx = np.absolute(sobelx) # Absolute x derivative to accentuate lines away from horizontal
        scaled_sobel = np.uint8(255*abs_sobelx/np.max(abs_sobelx))
        
        # Threshold x gradient
        sxbinary = np.zeros_like(scaled_sobel)
        sxbinary[(scaled_sobel >= sx_thresh[0]) & (scaled_sobel <= sx_thresh[1])] = 1
        
        # Threshold color channel
        s_binary = np.zeros_like(s_channel)
        s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1
        # Stack each channel
        color_binary = np.dstack(( np.zeros_like(sxbinary), sxbinary, s_binary)) *255
        return color_binary
    

    有了二进制的车道线图像,就可以进一步拟合车道线曲线,首先画车道线二进制图的像素直方图,取下半张图片,像素最多的位置作为车道线的起始位置,然后自定义窗口大小和个数向上做滑窗操作,求出每个窗口中像素点的x和y坐标作为车道线的x,y坐标,当前窗口像素的平均x坐标作为下一个滑窗的中心位置,有了全部滑窗和车道线坐标用cv2.fitpoly函数拟合车道线曲线方程
    在这里插入图片描述

    def find_line_pixels(binary_warped):
        # Take a histogram of the bottom half of the image
        histogram = np.sum(binary_warped[binary_warped.shape[0] // 2:, :], axis=0)
        # Find the peak of the left and right halves of the histogram
        # These will be the starting point for the left and right lines
        midpoint = np.int(histogram.shape[0] / 2)
        leftx_base = np.argmax(histogram[:midpoint])
        rightx_base = np.argmax(histogram[midpoint:]) + midpoint
    
        # Choose the number of sliding windows
        nwindows = 9
        # Set height of windows
        window_height = np.int(binary_warped.shape[0] / nwindows)
        # Identify the x and y positions of all nonzero pixels in the image
        nonzero = binary_warped.nonzero()
        nonzeroy = np.array(nonzero[0])
        nonzerox = np.array(nonzero[1])
        # Current positions to be updated for each window
        leftx_current = leftx_base
        rightx_current = rightx_base
        # Set the width of the windows +/- margin
        margin = 100
        # Set minimum number of pixels found to recenter window
        minpix = 50
        # Create empty lists to receive left and right lane pixel indices
        left_lane_inds = []
        right_lane_inds = []
    
        # Step through the windows one by one
        for window in range(nwindows):
            # Identify window boundaries in x and y (and right and left)
            win_y_low = binary_warped.shape[0] - (window + 1) * window_height
            win_y_high = binary_warped.shape[0] - window * window_height
            win_xleft_low = leftx_current - margin
            win_xleft_high = leftx_current + margin
            win_xright_low = rightx_current - margin
            win_xright_high = rightx_current + margin
            # Identify the nonzero pixels in x and y within the window
            good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
                              (nonzerox >= win_xleft_low) & (nonzerox < win_xleft_high)).nonzero()[0]
            good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
                               (nonzerox >= win_xright_low) & (nonzerox < win_xright_high)).nonzero()[0]
            # Append these indices to the lists
            left_lane_inds.append(good_left_inds)
            right_lane_inds.append(good_right_inds)
            # If you found > minpix pixels, recenter next window on their mean position
            if len(good_left_inds) > minpix:
                leftx_current = np.int(np.mean(nonzerox[good_left_inds]))
            if len(good_right_inds) > minpix:
                rightx_current = np.int(np.mean(nonzerox[good_right_inds]))
    
        # Concatenate the arrays of indices
        left_lane_inds = np.concatenate(left_lane_inds)
        right_lane_inds = np.concatenate(right_lane_inds)
    
        # Extract left and right line pixel positions
        leftx = nonzerox[left_lane_inds]
        lefty = nonzeroy[left_lane_inds]
        rightx = nonzerox[right_lane_inds]
        righty = nonzeroy[right_lane_inds]
    
        # Fit a second order polynomial to each
        left_fit = np.polyfit(lefty, leftx, 2)
        right_fit = np.polyfit(righty, rightx, 2)
    
    
        return left_fit, right_fit, left_lane_inds, right_lane_inds, lefty, leftx, righty, rightx
    
    
        
    

    滑窗的方法通常用于第一帧或者检测失败重新开始的检测,因为对计算资源浪费过多,检测时间长,由于连续帧图像之间相差不大,之后几帧的图像可以只对第一帧拟合的曲线周围检测,设置周围的margin,然后在该范围内寻找下一帧曲线的像素点从而拟合曲线。但是再最后处理每一帧图像时要设置标志位检测是否检测到拟合的曲线,检测到的话用search_from_previous方法,否则的话要用滑窗的方法重新寻找车道线。
    在这里插入图片描述

    
    def search_from_previous(binary_warped, left_fit, right_fit):
        nonzero = binary_warped.nonzero()
        nonzeroy = np.array(nonzero[0])
        nonzerox = np.array(nonzero[1])
        margin = 100
        left_lane_inds = ((nonzerox > (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy +
                                       left_fit[2] - margin)) & (nonzerox < (left_fit[0] * (nonzeroy ** 2) +
                                                                             left_fit[1] * nonzeroy + left_fit[
                                                                                 2] + margin)))
    
        right_lane_inds = ((nonzerox > (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy +
                                        right_fit[2] - margin)) & (nonzerox < (right_fit[0] * (nonzeroy ** 2) +
                                                                               right_fit[1] * nonzeroy + right_fit[
                                                                                   2] + margin)))
    
        # Again, extract left and right line pixel positions
        leftx = nonzerox[left_lane_inds]
        lefty = nonzeroy[left_lane_inds]
        rightx = nonzerox[right_lane_inds]
        righty = nonzeroy[right_lane_inds]
        # Fit a second order polynomial to each
        left_fit = np.polyfit(lefty, leftx, 2)
        right_fit = np.polyfit(righty, rightx, 2)
        return left_fit, right_fit, left_lane_inds, right_lane_inds,lefty,leftx,righty,rightx
    

    有了曲线的方程,则可以根据曲线曲率半径的公式计算曲率,dx/dy是因为我们拟合的是x对y的方程,因为车道线基本垂直,y对x的函数可能会存在一个y队形多个x的情况,这里还要注意自己计算的车道线曲线是根据像素值计算的,还要转换为其对应的实际道路距离(m)。
    对于车辆的偏移,我们可以假设摄像头安装在车辆的正中心,那么道路中心就是检测到的图像中两条车道线的中点,车道线中心和图像中心的偏移就是车辆相对于车道线的偏移。同样记得把像素值转换为实际道路记录(m)。

    在这里插入图片描述

    
      def measure_radius_of_curvature(warped_img, lefty, leftx, righty, rightx):
        ym_per_pix = 20 / 720  # meters per pixel in y dimension
        xm_per_pix = 3.7 / 800  # meters per pixel in x dimension
    
        # Fit a second order polynomial to pixel positions in each fake lane line
        # Fit new polynomials to x,y in world space
        left_fit_cr = np.polyfit(lefty*ym_per_pix, leftx*xm_per_pix, 2)
        right_fit_cr = np.polyfit(righty*ym_per_pix, rightx*xm_per_pix, 2)
    
        ploty = np.linspace(0, warped_img.shape[0] - 1, warped_img.shape[0])
    
        # Define y-value where we want radius of curvature
        # We'll choose the maximum y-value, corresponding to the bottom of the image
        y_eval = np.max(ploty)
    
        #Implement the calculation of R_curve (radius of curvature)
        left_curverad = ((1 + (2 * left_fit_cr[0] * y_eval * ym_per_pix + left_fit_cr[1]) ** 2) ** 1.5) / np.absolute(
            2 * left_fit_cr[0])
        right_curverad = ((1 + (2 * right_fit_cr[0] * y_eval * ym_per_pix + right_fit_cr[1]) ** 2) ** 1.5) / np.absolute(
            2 * right_fit_cr[0])
    
        left_lane_bottom = left_fit_cr[0] * (y_eval* ym_per_pix) ** 2 + left_fit_cr[0] * y_eval* ym_per_pix + left_fit_cr[2]
        right_lane_bottom = right_fit_cr[0] * (y_eval* ym_per_pix) ** 2 + right_fit_cr[0] * y_eval* ym_per_pix + right_fit_cr[2]
    
        # Lane center as mid of left and right lane bottom
        lane_center = (left_lane_bottom + right_lane_bottom) / 2.
        center_image = np.float(1280/2*xm_per_pix)
        center = lane_center - center_image  # Convert to meters
        position = "left" if center < 0 else "right"
        center = "Vehicle is {:.2f}m {}".format(center, position)
    
        # Now our radius of curvature is in meters
        return left_curverad, right_curverad, center
    

    这就是完整的车道线检测流程了,对于一些连续弯道导致车道线超出图像边界的情况日后解决了会更新。

    展开全文
  • USB 2.0 to COM Device 串口线 驱动程序

    千次下载 热门讨论 2012-03-29 16:28:48
    “USB 2.0 to COM Device” USB转串口线驱动程序
  • 随着USB PD快充协议的普及,USB-C to USB-C数据线市场占有率不断提升。这种线缆拥有传统线缆无法比拟的优势–支持USB3.1数据传输以及电流20V/5A 100W电力传输。 承载5A的电流的USB-C to USB-C线材必须配备E-Marker...

    随着USB PD快充协议的普及,USB-C to USB-C数据线市场占有率不断提升。这种线缆拥有传统线缆无法比拟的优势–支持USB3.1数据传输以及电流20V/5A 100W电力传输。

    承载5A的电流的USB-C to USB-C线材必须配备E-Marker芯片,然而5A只是电流承载能力,对于输出传输来说,还需要区分是USB 2.0接口还是USB 3.1 Gen1或者USB 3.1 Gen2,所以USB-C to USB-C线材的分类也比较多。苹果笔记本随机的就是USB 2.0数据接口的5A线材。

    由于这种高标准的数据线目前是市场上并不多,同时将会有很大的市场空间,但是开博尔公司在4月底即将上架一款USB 3.1 Gen2 Type-C数据线,我们来提前了解一下这款数据线有何特点。

    线体直径4.8MM,内部线材质量上乘。TPE外被,材质健康环保,锌合金金属接口,一体成型,坚固耐用。内部芯线为镀锌铜线,传输速率快,外加多层屏蔽层,抵抗外界干扰。

    数据线配备E-Marker芯片为什么一个传输速率好的数据线要配备E-Marker r芯片呢,我们从USB-IF协会的标准中了解到,当USB-C线缆的传输速度为USB 2.0时,是不要求配E-marker芯片的。但是当传输速度达到USB 3.1 Gen1(5Gbps)或者USB 3.1 Gen2(10Gbps)时,就必须使用E-Marker芯片,这与USB-C线缆对功率没太大关系。但是E-Marker芯片在标记线缆数据性能的同时,也会标记线缆的电力传输能力。 

      所以,这款开博尔数据线支持USB 3.1 Gen2传输速率,那E-Marker芯片是必不可少的。

    展开全文
  • 摘要 一般的车道线检测算法分为两步,第一步进行...本文提出一个一步到位的端到端训练的车道线检测算法,包含两个部分:(1)预测weight map的卷积神经网络 (2)一个用于拟合车道线的可微的最小二乘法拟合模块 ...

    论文链接

    https://arxiv.org/pdf/1902.00293

    动机

    一般的车道线检测算法分为两步,第一步进行图像分割,第二步对分割结果进行后处理。这种2-step的方法不是直接预测车道线,所以通过分割的方式预测车道线不一定能够实现最佳的表现。

    贡献

    提出一个可以直接预测车道线的方法。利用最小二乘法可微的性质,实现车道线检测网络端到端的训练。车道线检测网络分为两个部分:(1)一个用于预测weight map的深度神经网络 (2)一个可微最小二乘法拟合模块

    算法

    Overview1、输入:(1)使用一个固定转换矩阵H对RGB图片转换视角后的RGB鸟瞰图 (2)每个像素点在x轴方向坐标归一化后的x-map (3)每个像素点在y轴方向坐标归一化后的y-map
    2、预测过程:(1)首先将RGB图片输入deep network获得多个weight map,每个weight map对应一条可能存在的车道线
    (2)将weight maps,x-map以及y-map输入到least-squares layer,进行最小二乘法线性回归拟合训练,获得拟合各个车道线的函数的常量值,具体过程如下:
    假设要检测n条车道线,则需要去拟合这条车道线获得函数常量值表示该函数。传统线性回归方法如下:
    eq1其中m是图像的分辨率,X的一行是一个车道线的x轴方向坐标值,Y的一行是一个车道线的y轴方向的坐标值。本质上这就是一个线性回归问题。把车道线视作一个连续函数曲线,能够通过求β值得到这些函数,从而在图片中准确定位车道线。通过最小二乘法,可以得到β的值:beita
    为了把图片中的上下文信息融合到车道线的定位中,本文将通过deep network提取的weight map加入车道线拟合计算中,所以对上式进行改进:
    在这里插入图片描述
    nn加入weight map后,线性回归过程中会结合图片特征实现拟合车道线的函数的常量预测。
    3、输出:拟合车道线的函数的常量值β,也就得到拟合车道线的函数曲线,即车道线定位
    4、训练损失函数:最小二乘法线性回归是可微的,所以能够实现反向传播,不需要把其作为独立的后处理操作。从而可以和deep network一起训练。
    一般的损失函数:
    在这里插入图片描述
    但是上述损失函数没有考虑到β向量中每个分量的敏感性。也许β中某个分量很小,但是这个分量的轻微变动就会导致最终函数曲线的巨大波动,类似蝴蝶效应。而有的分量剧烈波动但对曲线影响很小。所以考虑到β向量的各个分量的敏感性不同,重新设计了一个几何损失函数:
    在这里插入图片描述
    其中t是一个设置好的固定值。从积分的角度来看,其本质上就是求两个函数曲线在x∈(0,t)范围内的围成的区域在高度变为原来的平方后的面积,如下图所示。面积越大,说明越不拟合,几何损失自然也越大。
    在这里插入图片描述对于一次函数和二次函数,都可以求得L的积分公式,能够进行反向传播
    在这里插入图片描述

    实验

    数据集

    使用TuSimple数据集,并手工清除了部分车道线不清晰的图片。80%数据训练,20%数据验证。

    评价指标

    loss:在训练过程中几何损失函数的损失值
    error:在这里插入图片描述预测函数曲线和GT车道曲线在x∈(0,t)范围内的围成的区域的面积大小。

    结果

    在这里插入图片描述cross-entropy:使用先进行语义二值分割后根据分割结果获得拟合曲线的2-step方式进行车道线检测

    优缺点

    优点:利用最小二乘法线性回归能够拟合曲线以及可微的性质,能够实现一步到位的端到端训练,直接预测拟合车道线的函数常量值。
    缺点:deep network中的weight map固定,只能预测固定数目的车道线,无法在车道线数量变化时自适应。同时由于只用函数曲线拟合车道线,忽略了车道线的粗细情况。

    总结反思

    个人思考:
    (1)将deep network分成两个branch输出,一个输出weight map,用于最小二乘线性线性回归,另一个用于语义分割。最后将预测的拟合车道线的函数和语义分割后的车道线进行综合,进一步通过互补纠正车道线定位,提高准确率。
    (2)既然可以使用线性回归方式拟合车道线,实现车道线的定位,那么是否可以去拟合其他更加复杂的形状,从而实现图像中一些特定目标的定位?

    展开全文
  • Selenium-switch_to_window出现删除线

    千次阅读 2019-10-08 19:20:27
    switch_to_window()在使用时出现了删除线,让人心慌慌。 原来是这个方法老了,换成: switch_to.window()就ok了 转载于:https://www.cnblogs.com/Lixinhang/p/10942046.html...
  • //MoveTo和LineTo线部分 //定义p0和p1两个点 CPoint m_p0(-200,50),m_p1(200,50); //声明两个CPen对象 CPen m_newPen,*m_oldPen; //创建新画笔 m_newPen.CreatePen(PS_SOLID,1,RGB(0,0,255)); //将新画笔...
  • Towards End-to-End Lane Detection: an Instance Segmentation Approach In IEEE Intelligent Vehicles Symposium (IV’18) https://github.com/MaybeShewill-CV/lanenet-lane-detection 以前的CNN网络将所有的车道...
  • 突然,有人来到他旁边,拍了拍他的肩膀,“你在干什么呢?”扭过头,笛卡尔看到一张年轻秀丽的睑庞,一双清澈的眼睛如湛蓝的湖水,楚楚动人,长长的睫毛一眨一眨的,期待着他的回应。她就是瑞典的小公主,国王最宠爱...
  • 我在w3c的手册里面看到用moveTo和lineTo绘制线条讲的不是很清楚,尤其是moveTo和lineTo函数没有说的很明白!所以特地在这里与新手朋友分享一下我的理解!  一、w3c里面的代码和实现效果  ...
  • 从头开始构建 DevOps 流水线。推动该计划的核心技术是 Jenkins,这是一个用于建立持续集成和持续交付(CI/CD)流水线的开源工具。 在花旗,有一个单独的团队为专用的 Jenkins 流水线提供稳定的主从节点环境,但是该...
  • 我先用excel表格,输入了ID X Y 坐标,一共四个点,然后先ADD XY DATA...然后我用Arctoolbox中的Points to Line工具,导入Export出来的SHP文件,Sort方式选择了按ID顺序,点OK运行提示说失败. 请问大神哪里出了问题 求解答T T
  • 光刻中G线,I线,H线什么叫G线,I线,H线而不是叫别的什么线?如果是我就叫A线B线C线D线,又简单又好记忆。G,I,H有什么含义吗,是什么英文单词的简写吗?  已经知道G线,I线,H线对应高压汞灯光谱中波长不同的...
  • Failed to connect to 192.168.37.129 port 80: Connection refused ERROR: Job failed: exit status 1 网上找了好多方法,发现原因是 Connection refused 很少,一直尝试了好多方法,甚至想重新安装一个新的...
  • 最终我们是要实现slam功能,而slam需要...可以通过pointcloud_to_laserscan包实现。 1,安装pointcloud_to_laserscan包 cd ~/catkin_ws/src git clone https://github.com/ros-perception/pointcloud_to_lasersc...
  • Openlayers4中实现动态线效果

    千次阅读 2017-10-01 20:04:02
    本文讲述如何结合canvas在Openlayers4中实现动态线的效果
  • 什么梯度方向与等高线垂直

    千次阅读 2018-10-22 11:42:36
    有些结论用起来习以为常,却不知道背后的原理,比如为什么梯度方向与等高线垂直,弄明白后心里才舒畅 要解决这个问题首先得有等高线的数学表达式 等高线的法线 以三维空间为例, 设某曲面的表达式为z=f(x,y)z=f(x,y)z=f...
  • 因为在全网搜索Gilbert Strang编写的Introduction to Linear Algebra时找不到中文翻译版,所以有了人工翻译这本书的想法。 【书名】Introduction to Linear Algebra 【作者】Gilbert Strang 【版本】2016年发行的第...
  • 深度学习检测车道线(一)

    万次阅读 多人点赞 2019-01-19 10:37:41
    最近在用深度学习的方法进行车道线检测,现总结如下: 目前,对于车道线检测的方法主要分为两大类,一是基于传统机器视觉的方法,二是基于深度学习大方法。 一、基于传统机器视觉的方法 1. 边缘检测+霍夫变换 方法...
  • Display to Vga 高清转接器产品/Display to Vga 高清1080P转接线产品特点: DisplayPort为新一代影像显示接口技术的规格之一,可将笔记型计算机和消费电子设备连接到显示器,传递高画质影像信号。根据iSuppli的预测...
  • 线、绳、头发等的)股,缕 My daughter used to play with the dog by taking a strand of its hair and then spending a long time rubbing, combing and twisting it. 我女儿过去常和这只狗玩耍,把它的一缕...
  • 视频处理中,经常有做一些行人、车辆或者其它运动物体越线检测,越界检测。原视频流:下面用opencv介绍两种方式,画直线(越线、拌线):第一种:固定第一帧,或者暂停视频,在固定的一帧中完成画直线的功能 #include...
  • Matplotlib

    万次阅读 多人点赞 2018-08-23 23:28:21
    Pyplot简介 matplotlib.pyplot 是一个命令风格的函数集合,这使得 matplotlib 工作起来和...每一个 pyplot 函数都会使图形发生一些变化,例如:创建一幅图形、在一幅图中创建一个绘图区域、在绘图区域中绘制一些线...
  • 电脑网线平行线与交叉线的用途?

    千次阅读 2018-03-21 17:28:21
    引言 局域网之间的连接,要看网卡支持不支持这种接法,现在新出的网卡有些是可以支持这种接法的,有些则不行。...正文 双绞线一般有三种线序:直通(Straight-through),交叉(Cross-over)和全反(Ro...
  • 串口线接法是什么 详细步骤介绍

    千次阅读 2017-07-10 10:30:00
    一个完整的RS-232C接口有22根线,采用标准的25芯插头座(或者9芯插头座)。25芯和9芯的主要信号线相同。以下的介绍是以25芯的RS-232C为例。  ①主要信号线定义: 2脚:发送数据TXD; 3脚:接收数据RXD; 4脚:请求...
  • USB转RJ45串口调试线(console线

    千次阅读 2021-03-12 07:13:13
    USB转RJ45串口调试线(console线)1 介绍一般常用芯片console线图示2 接线定义参考 1 介绍 Console接口是典型的配置接口。使用Console线直接连接至计算机的串口,利用终端仿真程序(一般使用Windows自带的“超级终端...
  • JLINK提示下载:ERROR: Failed to connect Connecting … - Connecting via USB to J-Link device 0 - J-Link firmware: V1 解决方法: ①假若单片机进入停机模式,增加一条NREST引脚连接下图中的RESET引脚,若...
  • Emulator: emulator: ERROR: AdbHostServer.cpp:102: Unable to connect to adb daemon on port: 5037 网上找了很多,各种提示要我配置adb的环境变量,杀死占用5037端口的线程…… 毛用没得…… 解决方案:允许...
  • 测地线就是在一个三维物体的表面上找出两个点的最短距离。测地线的具体应用挺广的,比如说飞机船只的航道设计。首先我们知道在二维平面上两点之间线段最短,但若是换到三维这就没办法实现了,因为你无...
  • geotools等值线生成

    千次阅读 2018-06-03 14:28:44
    前文中,提到了等值面的生成,后面有人经常会问等值线的生成,本文在前文的基础上做了一点修改,完成了等值线的geotools生成。 效果 实现代码 package com.lzugis.geotools; import ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 530,181
精华内容 212,072
关键字:

to线是什么线