Advanced_Lane_Finding_v2.py
def find_window_centroids(binary_warped, nwindows=9, margin=100):
    """
    Implementation provided by Udacity of lane search with sliding windows
    :param binary_warped: binary warped image with segmented lane lines
    :param nwindows: 
    :param margin: 
    :return: 
    """

    # Assuming you have created a warped binary image called "binary_warped"
    # Take a histogram of the bottom half of the image
    histogram = np.sum(binary_warped[int(binary_warped.shape[0] / 2):, :], axis=0)
    # Create an output image to draw on and  visualize the result
    #out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255
    # 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

    # 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 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)

    # Generate x and y values for plotting
    ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0])
    left_fitx = left_fit[0] * ploty ** 2 + left_fit[1] * ploty + left_fit[2]
    right_fitx = right_fit[0] * ploty ** 2 + right_fit[1] * ploty + right_fit[2]

    return left_fit, right_fit, ploty, left_fitx, right_fitx

    Implementation provided by Udacity of lane search with sliding windows
    :param binary_warped: binary warped image with segmented lane lines
    :param nwindows: 
    :param margin: 
    :return: 
    
Implementation provided by Udacity of lane search with sliding windows
Implementation provided by Udacity of lane search with sliding windows
def find_window_centroids(binary_warped, nwindows=9, margin=100):
    histogram = np.sum(binary_warped[int(binary_warped.shape[0] / 2):, :], axis=0)
    midpoint = np.int(histogram.shape[0] / 2)
    leftx_base = np.argmax(histogram[:midpoint])
    rightx_base = np.argmax(histogram[midpoint:]) + midpoint
    window_height = np.int(binary_warped.shape[0] / nwindows)
    nonzero = binary_warped.nonzero()
    nonzeroy = np.array(nonzero[0])
    nonzerox = np.array(nonzero[1])
    leftx_current = leftx_base
    rightx_current = rightx_base
    minpix = 50
    left_lane_inds = []
    right_lane_inds = []
    for window in range(nwindows):
        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
        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]
        left_lane_inds.append(good_left_inds)
        right_lane_inds.append(good_right_inds)
        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]))
    left_lane_inds = np.concatenate(left_lane_inds)
    right_lane_inds = np.concatenate(right_lane_inds)
    leftx = nonzerox[left_lane_inds]
    lefty = nonzeroy[left_lane_inds]
    rightx = nonzerox[right_lane_inds]
    righty = nonzeroy[right_lane_inds]
    left_fit = np.polyfit(lefty, leftx, 2)
    right_fit = np.polyfit(righty, rightx, 2)
    ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0])
    left_fitx = left_fit[0] * ploty ** 2 + left_fit[1] * ploty + left_fit[2]
    right_fitx = right_fit[0] * ploty ** 2 + right_fit[1] * ploty + right_fit[2]
    return left_fit, right_fit, ploty, left_fitx, right_fitx
def find_window_centroids ( binary_warped , nwindows = 9 , margin = 100 ) : histogram = np . sum ( binary_warped [ int ( binary_warped . shape [ 0 ] / 2 ) : , : ] , axis = 0 ) midpoint = np . int ( histogram . shape [ 0 ] / 2 ) leftx_base = np . argmax ( histogram [ : midpoint ] ) rightx_base = np . argmax ( histogram [ midpoint : ] ) + midpoint window_height = np . int ( binary_warped . shape [ 0 ] / nwindows ) nonzero = binary_warped . nonzero ( ) nonzeroy = np . array ( nonzero [ 0 ] ) nonzerox = np . array ( nonzero [ 1 ] ) leftx_current = leftx_base rightx_current = rightx_base minpix = 50 left_lane_inds = [ ] right_lane_inds = [ ] for window in range ( nwindows ) : 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 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 ] left_lane_inds . append ( good_left_inds ) right_lane_inds . append ( good_right_inds ) 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 ] ) ) left_lane_inds = np . concatenate ( left_lane_inds ) right_lane_inds = np . concatenate ( right_lane_inds ) leftx = nonzerox [ left_lane_inds ] lefty = nonzeroy [ left_lane_inds ] rightx = nonzerox [ right_lane_inds ] righty = nonzeroy [ right_lane_inds ] left_fit = np . polyfit ( lefty , leftx , 2 ) right_fit = np . polyfit ( righty , rightx , 2 ) ploty = np . linspace ( 0 , binary_warped . shape [ 0 ] - 1 , binary_warped . shape [ 0 ] ) left_fitx = left_fit [ 0 ] * ploty ** 2 + left_fit [ 1 ] * ploty + left_fit [ 2 ] right_fitx = right_fit [ 0 ] * ploty ** 2 + right_fit [ 1 ] * ploty + right_fit [ 2 ] return left_fit , right_fit , ploty , left_fitx , right_fitx
Implementation provided by Udacity of lane search with sliding windows
Implementation provided by Udacity of lane search with sliding windows
"""
    Implementation provided by Udacity of lane search with sliding windows
    :param binary_warped: binary warped image with segmented lane lines
    :param nwindows: 
    :param margin: 
    :return: 
    """ # Assuming you have created a warped binary image called "binary_warped" # Take a histogram of the bottom half of the image # Create an output image to draw on and  visualize the result #out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255 # Find the peak of the left and right halves of the histogram # These will be the starting point for the left and right lines # Set height of windows # Identify the x and y positions of all nonzero pixels in the image # Current positions to be updated for each window # Set minimum number of pixels found to recenter window # Create empty lists to receive left and right lane pixel indices # Step through the windows one by one # Identify window boundaries in x and y (and right and left) # Identify the nonzero pixels in x and y within the window # Append these indices to the lists # If you found > minpix pixels, recenter next window on their mean position # Concatenate the arrays of indices # Extract left and right line pixel positions # Fit a second order polynomial to each # Generate x and y values for plotting
None
binary_warped
binary warped image with segmented lane lines
binary warped image with segmented lane lines
nwindows
None
margin
None