• OpenCV“迷雾”车道识别的反思

    标题有些拗口，就这样吧。

    这个例子就是为了说明，算力离智能还有很远很远的距离。

    机器人迷雾之算力与智能_zhangrelay的博客-CSDN博客

    测试图片如下：

    车道图

    其中第一幅图是仿真案例：

    ROS2+Gazebo+OpenCV之mobot仿真视觉传感器_zhangrelay的博客-CSDN博客 

    在如上文章中提及。

    同时，可以参考：

     机器人方向的刚性需求→个人思考←_zhangrelay的博客-CSDN博客

    只有一个图可用，如下：

    一看效果太好了，可以上路测试啦。

    其实，换个图基本就不行了，但是人眼分辨所有测试图都是不会出错的。

    看个离谱的：

    妙不妙？

    更离谱的：

    慌不慌？

    疑问一：参数不合适。

    反问，人在不同城市开车或者走路的时候，会先调参数吗？

    疑问二：算法不够智能。

    反问，算法是计算方法，和智能有联系，但关联性参考：

    “机器人迷雾之算力与智能“

    疑问三，这种方式合适吗。

    思考：先抛开算法，仅仅考虑算力，类比一个人类指标智力。

    开车开的好的人，一定学历高吗？

    赛车手中，高学历一定成绩有优势吗……

    还是先回归常识，再搞算法，否则，事倍功半。

    目前，有会独立思考的机器人程序吗？或者真正意义上的智能体？

    附录

    测试算法如下（引用）：

    1. import cv2 # Import the OpenCV library to enable computer vision
    2. import numpy as np # Import the NumPy scientific computing library
    3. import edge_detection as edge # Handles the detection of lane lines
    4. import matplotlib.pyplot as plt # Used for plotting and error checking
    5.  
    6. # Author: Addison Sears-Collins
    7. # Description: Implementation of the Lane class 
    8.  
    9. # Make sure the video file is in the same directory as your code
    10. filename = 'orig_lane_detection_1.mp4'
    11. file_size = (1920,1080) # Assumes 1920x1080 mp4
    12. scale_ratio = 1 # Option to scale to fraction of original size. 
    13.  
    14. # We want to save the output to a video file
    15. output_filename = 'orig_lane_detection_1_lanes.mp4'
    16. output_frames_per_second = 20.0 
    17.  
    18. # Global variables
    19. prev_leftx = None
    20. prev_lefty = None
    21. prev_rightx = None
    22. prev_righty = None
    23. prev_left_fit = []
    24. prev_right_fit = []
    25.  
    26. prev_leftx2 = None
    27. prev_lefty2 = None
    28. prev_rightx2 = None
    29. prev_righty2 = None
    30. prev_left_fit2 = []
    31. prev_right_fit2 = []
    32.  
    33. class Lane:
    34.   """
    35.   Represents a lane on a road.
    36.   """
    37.   def __init__(self, orig_frame):
    38.     """
    39. 	  Default constructor
    40. 		
    41.     :param orig_frame: Original camera image (i.e. frame)
    42.     """
    43.     self.orig_frame = orig_frame
    44.  
    45.     # This will hold an image with the lane lines		
    46.     self.lane_line_markings = None
    47.  
    48.     # This will hold the image after perspective transformation
    49.     self.warped_frame = None
    50.     self.transformation_matrix = None
    51.     self.inv_transformation_matrix = None
    52.  
    53.     # (Width, Height) of the original video frame (or image)
    54.     self.orig_image_size = self.orig_frame.shape[::-1][1:]
    55.  
    56.     width = self.orig_image_size[0]
    57.     height = self.orig_image_size[1]
    58.     self.width = width
    59.     self.height = height
    60. 	
    61.     # Four corners of the trapezoid-shaped region of interest
    62.     # You need to find these corners manually.
    63.     self.roi_points = np.float32([
    64.       (int(0.456*width),int(0.544*height)), # Top-left corner
    65.       (0, height-1), # Bottom-left corner			
    66.       (int(0.958*width),height-1), # Bottom-right corner
    67.       (int(0.6183*width),int(0.544*height)) # Top-right corner
    68.     ])
    69. 		
    70.     # The desired corner locations  of the region of interest
    71.     # after we perform perspective transformation.
    72.     # Assume image width of 600, padding == 150.
    73.     self.padding = int(0.25 * width) # padding from side of the image in pixels
    74.     self.desired_roi_points = np.float32([
    75.       [self.padding, 0], # Top-left corner
    76.       [self.padding, self.orig_image_size[1]], # Bottom-left corner			
    77.       [self.orig_image_size[
    78.         0]-self.padding, self.orig_image_size[1]], # Bottom-right corner
    79.       [self.orig_image_size[0]-self.padding, 0] # Top-right corner
    80.     ]) 
    81. 		
    82.     # Histogram that shows the white pixel peaks for lane line detection
    83.     self.histogram = None
    84. 		
    85.     # Sliding window parameters
    86.     self.no_of_windows = 10
    87.     self.margin = int((1/12) * width)  # Window width is +/- margin
    88.     self.minpix = int((1/24) * width)  # Min no. of pixels to recenter window
    89. 		
    90.     # Best fit polynomial lines for left line and right line of the lane
    91.     self.left_fit = None
    92.     self.right_fit = None
    93.     self.left_lane_inds = None
    94.     self.right_lane_inds = None
    95.     self.ploty = None
    96.     self.left_fitx = None
    97.     self.right_fitx = None
    98.     self.leftx = None
    99.     self.rightx = None
    100.     self.lefty = None
    101.     self.righty = None
    102. 		
    103.     # Pixel parameters for x and y dimensions
    104.     self.YM_PER_PIX = 7.0 / 400 # meters per pixel in y dimension
    105.     self.XM_PER_PIX = 3.7 / 255 # meters per pixel in x dimension
    106. 		
    107.     # Radii of curvature and offset
    108.     self.left_curvem = None
    109.     self.right_curvem = None
    110.     self.center_offset = None
    111.  
    112.   def calculate_car_position(self, print_to_terminal=False):
    113.     """
    114.     Calculate the position of the car relative to the center
    115. 		
    116.     :param: print_to_terminal Display data to console if True		
    117.     :return: Offset from the center of the lane
    118.     """
    119.     # Assume the camera is centered in the image.
    120.     # Get position of car in centimeters
    121.     car_location = self.orig_frame.shape[1] / 2
    122.  
    123.     # Fine the x coordinate of the lane line bottom
    124.     height = self.orig_frame.shape[0]
    125.     bottom_left = self.left_fit[0]*height**2 + self.left_fit[
    126.       1]*height + self.left_fit[2]
    127.     bottom_right = self.right_fit[0]*height**2 + self.right_fit[
    128.       1]*height + self.right_fit[2]
    129.  
    130.     center_lane = (bottom_right - bottom_left)/2 + bottom_left 
    131.     center_offset = (np.abs(car_location) - np.abs(
    132.       center_lane)) * self.XM_PER_PIX * 100
    133.  
    134.     if print_to_terminal == True:
    135.       print(str(center_offset) + 'cm')
    136. 			
    137.     self.center_offset = center_offset
    138.       
    139.     return center_offset
    140.  
    141.   def calculate_curvature(self, print_to_terminal=False):
    142.     """
    143.     Calculate the road curvature in meters.
    145.     :param: print_to_terminal Display data to console if True
    146.     :return: Radii of curvature
    147.     """
    148.     # Set the y-value where we want to calculate the road curvature.
    149.     # Select the maximum y-value, which is the bottom of the frame.
    150.     y_eval = np.max(self.ploty)    
    151.  
    152.     # Fit polynomial curves to the real world environment
    153.     left_fit_cr = np.polyfit(self.lefty * self.YM_PER_PIX, self.leftx * (
    154.       self.XM_PER_PIX), 2)
    155.     right_fit_cr = np.polyfit(self.righty * self.YM_PER_PIX, self.rightx * (
    156.       self.XM_PER_PIX), 2)
    157. 			
    158.     # Calculate the radii of curvature
    159.     left_curvem = ((1 + (2*left_fit_cr[0]*y_eval*self.YM_PER_PIX + left_fit_cr[
    160.                     1])**2)**1.5) / np.absolute(2*left_fit_cr[0])
    161.     right_curvem = ((1 + (2*right_fit_cr[
    162.                     0]*y_eval*self.YM_PER_PIX + right_fit_cr[
    163.                     1])**2)**1.5) / np.absolute(2*right_fit_cr[0])
    164. 	
    165.     # Display on terminal window
    166.     if print_to_terminal == True:
    167.       print(left_curvem, 'm', right_curvem, 'm')
    168. 			
    169.     self.left_curvem = left_curvem
    170.     self.right_curvem = right_curvem
    171.  
    172.     return left_curvem, right_curvem		
    173. 		
    174.   def calculate_histogram(self,frame=None,plot=True):
    175.     """
    176.     Calculate the image histogram to find peaks in white pixel count
    177. 		
    178.     :param frame: The warped image
    179.     :param plot: Create a plot if True
    180.     """
    181.     if frame is None:
    182.       frame = self.warped_frame
    183. 			
    184.     # Generate the histogram
    185.     self.histogram = np.sum(frame[int(
    186. 		      frame.shape[0]/2):,:], axis=0)
    187.  
    188.     if plot == True:
    189. 		
    190.       # Draw both the image and the histogram
    191.       figure, (ax1, ax2) = plt.subplots(2,1) # 2 row, 1 columns
    192.       figure.set_size_inches(10, 5)
    193.       ax1.imshow(frame, cmap='gray')
    194.       ax1.set_title("Warped Binary Frame")
    195.       ax2.plot(self.histogram)
    196.       ax2.set_title("Histogram Peaks")
    197.       plt.show()
    198. 			
    199.     return self.histogram
    200.  
    201.   def display_curvature_offset(self, frame=None, plot=False):
    202.     """
    203.     Display curvature and offset statistics on the image
    204. 		
    205.     :param: plot Display the plot if True
    206.     :return: Image with lane lines and curvature
    207.     """	
    208.     image_copy = None
    209.     if frame is None:
    210.       image_copy = self.orig_frame.copy()
    211.     else:
    212.       image_copy = frame
    213.  
    214.     cv2.putText(image_copy,'Curve Radius: '+str((
    215.       self.left_curvem+self.right_curvem)/2)[:7]+' m', (int((
    216.       5/600)*self.width), int((
    217.       20/338)*self.height)), cv2.FONT_HERSHEY_SIMPLEX, (float((
    218.       0.5/600)*self.width)),(
    219.       255,255,255),2,cv2.LINE_AA)
    220.     cv2.putText(image_copy,'Center Offset: '+str(
    221.       self.center_offset)[:7]+' cm', (int((
    222.       5/600)*self.width), int((
    223.       40/338)*self.height)), cv2.FONT_HERSHEY_SIMPLEX, (float((
    224.       0.5/600)*self.width)),(
    225.       255,255,255),2,cv2.LINE_AA)
    226. 			
    227.     if plot==True:       
    228.       cv2.imshow("Image with Curvature and Offset", image_copy)
    229. 			
    230.     return image_copy
    231.     
    232.   def get_lane_line_previous_window(self, left_fit, right_fit, plot=False):
    233.     """
    234.     Use the lane line from the previous sliding window to get the parameters
    235.     for the polynomial line for filling in the lane line
    236.     :param: left_fit Polynomial function of the left lane line
    237.     :param: right_fit Polynomial function of the right lane line
    238.     :param: plot To display an image or not
    239.     """
    240.     # margin is a sliding window parameter
    241.     margin = self.margin
    242.  
    243.     # Find the x and y coordinates of all the nonzero 
    244.     # (i.e. white) pixels in the frame.			
    245.     nonzero = self.warped_frame.nonzero()  
    246.     nonzeroy = np.array(nonzero[0])
    247.     nonzerox = np.array(nonzero[1])
    248. 		
    249.     # Store left and right lane pixel indices
    250.     left_lane_inds = ((nonzerox > (left_fit[0]*(
    251.       nonzeroy**2) + left_fit[1]*nonzeroy + left_fit[2] - margin)) & (
    252.       nonzerox < (left_fit[0]*(
    253.       nonzeroy**2) + left_fit[1]*nonzeroy + left_fit[2] + margin))) 
    254.     right_lane_inds = ((nonzerox > (right_fit[0]*(
    255.       nonzeroy**2) + right_fit[1]*nonzeroy + right_fit[2] - margin)) & (
    256.       nonzerox < (right_fit[0]*(
    257.       nonzeroy**2) + right_fit[1]*nonzeroy + right_fit[2] + margin))) 			
    258.     self.left_lane_inds = left_lane_inds
    259.     self.right_lane_inds = right_lane_inds
    260.  
    261.     # Get the left and right lane line pixel locations	
    262.     leftx = nonzerox[left_lane_inds]
    263.     lefty = nonzeroy[left_lane_inds] 
    264.     rightx = nonzerox[right_lane_inds]
    265.     righty = nonzeroy[right_lane_inds]	
    266.  
    267.     global prev_leftx2
    268.     global prev_lefty2 
    269.     global prev_rightx2
    270.     global prev_righty2
    271.     global prev_left_fit2
    272.     global prev_right_fit2
    273. 		
    274.     # Make sure we have nonzero pixels		
    275.     if len(leftx)==0 or len(lefty)==0 or len(rightx)==0 or len(righty)==0:
    276.       leftx = prev_leftx2
    277.       lefty = prev_lefty2
    278.       rightx = prev_rightx2
    279.       righty = prev_righty2
    280.  
    281.     self.leftx = leftx
    282.     self.rightx = rightx
    283.     self.lefty = lefty
    284.     self.righty = righty
    285. 		
    286.     left_fit = np.polyfit(lefty, leftx, 2)
    287.     right_fit = np.polyfit(righty, rightx, 2) 
    288.  
    289.     # Add the latest polynomial coefficients		
    290.     prev_left_fit2.append(left_fit)
    291.     prev_right_fit2.append(right_fit)
    292.  
    293.     # Calculate the moving average	
    294.     if len(prev_left_fit2) > 10:
    295.       prev_left_fit2.pop(0)
    296.       prev_right_fit2.pop(0)
    297.       left_fit = sum(prev_left_fit2) / len(prev_left_fit2)
    298.       right_fit = sum(prev_right_fit2) / len(prev_right_fit2)
    299.  
    300.     self.left_fit = left_fit
    301.     self.right_fit = right_fit
    302. 		
    303.     prev_leftx2 = leftx
    304.     prev_lefty2 = lefty 
    305.     prev_rightx2 = rightx
    306.     prev_righty2 = righty
    307. 		
    308.     # Create the x and y values to plot on the image
    309.     ploty = np.linspace(
    310.       0, self.warped_frame.shape[0]-1, self.warped_frame.shape[0]) 
    311.     left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
    312.     right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
    313.     self.ploty = ploty
    314.     self.left_fitx = left_fitx
    315.     self.right_fitx = right_fitx
    316. 		
    317.     if plot==True:
    318. 		
    319.       # Generate images to draw on
    320.       out_img = np.dstack((self.warped_frame, self.warped_frame, (
    321.                            self.warped_frame)))*255
    322.       window_img = np.zeros_like(out_img)
    323. 			
    324.       # Add color to the left and right line pixels
    325.       out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]
    326.       out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [
    327.                                                                      0, 0, 255]
    328.       # Create a polygon to show the search window area, and recast 
    329.       # the x and y points into a usable format for cv2.fillPoly()
    330.       margin = self.margin
    331.       left_line_window1 = np.array([np.transpose(np.vstack([
    332.                                     left_fitx-margin, ploty]))])
    333.       left_line_window2 = np.array([np.flipud(np.transpose(np.vstack([
    334.                                     left_fitx+margin, ploty])))])
    335.       left_line_pts = np.hstack((left_line_window1, left_line_window2))
    336.       right_line_window1 = np.array([np.transpose(np.vstack([
    337.                                      right_fitx-margin, ploty]))])
    338.       right_line_window2 = np.array([np.flipud(np.transpose(np.vstack([
    339.                                      right_fitx+margin, ploty])))])
    340.       right_line_pts = np.hstack((right_line_window1, right_line_window2))
    341. 			
    342.       # Draw the lane onto the warped blank image
    343.       cv2.fillPoly(window_img, np.int_([left_line_pts]), (0,255, 0))
    344.       cv2.fillPoly(window_img, np.int_([right_line_pts]), (0,255, 0))
    345.       result = cv2.addWeighted(out_img, 1, window_img, 0.3, 0)
    346.       
    347.       # Plot the figures 
    348.       figure, (ax1, ax2, ax3) = plt.subplots(3,1) # 3 rows, 1 column
    349.       figure.set_size_inches(10, 10)
    350.       figure.tight_layout(pad=3.0)
    351.       ax1.imshow(cv2.cvtColor(self.orig_frame, cv2.COLOR_BGR2RGB))
    352.       ax2.imshow(self.warped_frame, cmap='gray')
    353.       ax3.imshow(result)
    354.       ax3.plot(left_fitx, ploty, color='yellow')
    355.       ax3.plot(right_fitx, ploty, color='yellow')
    356.       ax1.set_title("Original Frame")  
    357.       ax2.set_title("Warped Frame")
    358.       ax3.set_title("Warped Frame With Search Window")
    359.       plt.show()
    360. 			
    361.   def get_lane_line_indices_sliding_windows(self, plot=False):
    362.     """
    363.     Get the indices of the lane line pixels using the 
    364.     sliding windows technique.
    365. 		
    366.     :param: plot Show plot or not
    367.     :return: Best fit lines for the left and right lines of the current lane 
    368.     """
    369.     # Sliding window width is +/- margin
    370.     margin = self.margin
    371.  
    372.     frame_sliding_window = self.warped_frame.copy()
    373.  
    374.     # Set the height of the sliding windows
    375.     window_height = np.int(self.warped_frame.shape[0]/self.no_of_windows)		
    376.  
    377.     # Find the x and y coordinates of all the nonzero 
    378.     # (i.e. white) pixels in the frame.	
    379.     nonzero = self.warped_frame.nonzero()
    380.     nonzeroy = np.array(nonzero[0])
    381.     nonzerox = np.array(nonzero[1])	
    382. 		
    383.     # Store the pixel indices for the left and right lane lines
    384.     left_lane_inds = []
    385.     right_lane_inds = []
    386. 		
    387.     # Current positions for pixel indices for each window,
    388.     # which we will continue to update
    389.     leftx_base, rightx_base = self.histogram_peak()
    390.     leftx_current = leftx_base
    391.     rightx_current = rightx_base
    392.  
    393.     # Go through one window at a time
    394.     no_of_windows = self.no_of_windows
    395. 		
    396.     for window in range(no_of_windows):
    397.       
    398.       # Identify window boundaries in x and y (and right and left)
    399.       win_y_low = self.warped_frame.shape[0] - (window + 1) * window_height
    400.       win_y_high = self.warped_frame.shape[0] - window * window_height
    401.       win_xleft_low = leftx_current - margin
    402.       win_xleft_high = leftx_current + margin
    403.       win_xright_low = rightx_current - margin
    404.       win_xright_high = rightx_current + margin
    405.       cv2.rectangle(frame_sliding_window,(win_xleft_low,win_y_low),(
    406.         win_xleft_high,win_y_high), (255,255,255), 2)
    407.       cv2.rectangle(frame_sliding_window,(win_xright_low,win_y_low),(
    408.         win_xright_high,win_y_high), (255,255,255), 2)
    409.  
    410.       # Identify the nonzero pixels in x and y within the window
    411.       good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & 
    412.                           (nonzerox >= win_xleft_low) & (
    413.                            nonzerox < win_xleft_high)).nonzero()[0]
    414.       good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & 
    415.                            (nonzerox >= win_xright_low) & (
    416.                             nonzerox < win_xright_high)).nonzero()[0]
    417. 														
    418.       # Append these indices to the lists
    419.       left_lane_inds.append(good_left_inds)
    420.       right_lane_inds.append(good_right_inds)
    421.         
    422.       # If you found > minpix pixels, recenter next window on mean position
    423.       minpix = self.minpix
    424.       if len(good_left_inds) > minpix:
    425.         leftx_current = np.int(np.mean(nonzerox[good_left_inds]))
    426.       if len(good_right_inds) > minpix:        
    427.         rightx_current = np.int(np.mean(nonzerox[good_right_inds]))
    428. 					
    429.     # Concatenate the arrays of indices
    430.     left_lane_inds = np.concatenate(left_lane_inds)
    431.     right_lane_inds = np.concatenate(right_lane_inds)
    432.  
    433.     # Extract the pixel coordinates for the left and right lane lines
    434.     leftx = nonzerox[left_lane_inds]
    435.     lefty = nonzeroy[left_lane_inds] 
    436.     rightx = nonzerox[right_lane_inds] 
    437.     righty = nonzeroy[right_lane_inds]
    438.  
    439.     # Fit a second order polynomial curve to the pixel coordinates for
    440.     # the left and right lane lines
    441.     left_fit = None
    442.     right_fit = None
    443. 		
    444.     global prev_leftx
    445.     global prev_lefty 
    446.     global prev_rightx
    447.     global prev_righty
    448.     global prev_left_fit
    449.     global prev_right_fit
    450.  
    451.     # Make sure we have nonzero pixels		
    452.     if len(leftx)==0 or len(lefty)==0 or len(rightx)==0 or len(righty)==0:
    453.       leftx = prev_leftx
    454.       lefty = prev_lefty
    455.       rightx = prev_rightx
    456.       righty = prev_righty
    457. 		
    458.     left_fit = np.polyfit(lefty, leftx, 2)
    459.     right_fit = np.polyfit(righty, rightx, 2) 
    460.  
    461.     # Add the latest polynomial coefficients		
    462.     prev_left_fit.append(left_fit)
    463.     prev_right_fit.append(right_fit)
    464.  
    465.     # Calculate the moving average	
    466.     if len(prev_left_fit) > 10:
    467.       prev_left_fit.pop(0)
    468.       prev_right_fit.pop(0)
    469.       left_fit = sum(prev_left_fit) / len(prev_left_fit)
    470.       right_fit = sum(prev_right_fit) / len(prev_right_fit)
    471.  
    472.     self.left_fit = left_fit
    473.     self.right_fit = right_fit
    474. 		
    475.     prev_leftx = leftx
    476.     prev_lefty = lefty 
    477.     prev_rightx = rightx
    478.     prev_righty = righty
    479.  
    480.     if plot==True:
    481. 		
    482.       # Create the x and y values to plot on the image  
    483.       ploty = np.linspace(
    484.         0, frame_sliding_window.shape[0]-1, frame_sliding_window.shape[0])
    485.       left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
    486.       right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
    487.  
    488.       # Generate an image to visualize the result
    489.       out_img = np.dstack((
    490.         frame_sliding_window, frame_sliding_window, (
    491.         frame_sliding_window))) * 255
    492. 			
    493.       # Add color to the left line pixels and right line pixels
    494.       out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]
    495.       out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [
    496.         0, 0, 255]
    497. 				
    498.       # Plot the figure with the sliding windows
    499.       figure, (ax1, ax2, ax3) = plt.subplots(3,1) # 3 rows, 1 column
    500.       figure.set_size_inches(10, 10)
    501.       figure.tight_layout(pad=3.0)
    502.       ax1.imshow(cv2.cvtColor(self.orig_frame, cv2.COLOR_BGR2RGB))
    503.       ax2.imshow(frame_sliding_window, cmap='gray')
    504.       ax3.imshow(out_img)
    505.       ax3.plot(left_fitx, ploty, color='yellow')
    506.       ax3.plot(right_fitx, ploty, color='yellow')
    507.       ax1.set_title("Original Frame")  
    508.       ax2.set_title("Warped Frame with Sliding Windows")
    509.       ax3.set_title("Detected Lane Lines with Sliding Windows")
    510.       plt.show()  		
    511. 			
    512.     return self.left_fit, self.right_fit
    513.  
    514.   def get_line_markings(self, frame=None):
    515.     """
    516.     Isolates lane lines.
    517.   
    518. 	  :param frame: The camera frame that contains the lanes we want to detect
    519.     :return: Binary (i.e. black and white) image containing the lane lines.
    520.     """
    521.     if frame is None:
    522.       frame = self.orig_frame
    523. 			
    524.     # Convert the video frame from BGR (blue, green, red) 
    525.     # color space to HLS (hue, saturation, lightness).
    526.     hls = cv2.cvtColor(frame, cv2.COLOR_BGR2HLS)
    527.  
    528.     ################### Isolate possible lane line edges ######################
    529. 		
    530.     # Perform Sobel edge detection on the L (lightness) channel of 
    531.     # the image to detect sharp discontinuities in the pixel intensities 
    532.     # along the x and y axis of the video frame.		     
    533.     # sxbinary is a matrix full of 0s (black) and 255 (white) intensity values
    534.     # Relatively light pixels get made white. Dark pixels get made black.
    535.     _, sxbinary = edge.threshold(hls[:, :, 1], thresh=(120, 255))
    536.     sxbinary = edge.blur_gaussian(sxbinary, ksize=3) # Reduce noise
    537. 		
    538.     # 1s will be in the cells with the highest Sobel derivative values
    539.     # (i.e. strongest lane line edges)
    540.     sxbinary = edge.mag_thresh(sxbinary, sobel_kernel=3, thresh=(110, 255))
    541.  
    542.     ######################## Isolate possible lane lines ######################
    543.   
    544.     # Perform binary thresholding on the S (saturation) channel 
    545.     # of the video frame. A high saturation value means the hue color is pure.
    546.     # We expect lane lines to be nice, pure colors (i.e. solid white, yellow)
    547.     # and have high saturation channel values.
    548.     # s_binary is matrix full of 0s (black) and 255 (white) intensity values
    549.     # White in the regions with the purest hue colors (e.g. >130...play with
    550.     # this value for best results).
    551.     s_channel = hls[:, :, 2] # use only the saturation channel data
    552.     _, s_binary = edge.threshold(s_channel, (130, 255))
    553. 	
    554.     # Perform binary thresholding on the R (red) channel of the 
    555. 		# original BGR video frame. 
    556.     # r_thresh is a matrix full of 0s (black) and 255 (white) intensity values
    557.     # White in the regions with the richest red channel values (e.g. >120).
    558.     # Remember, pure white is bgr(255, 255, 255).
    559.     # Pure yellow is bgr(0, 255, 255). Both have high red channel values.
    560.     _, r_thresh = edge.threshold(frame[:, :, 2], thresh=(120, 255))
    561.  
    562.     # Lane lines should be pure in color and have high red channel values 
    563.     # Bitwise AND operation to reduce noise and black-out any pixels that
    564.     # don't appear to be nice, pure, solid colors (like white or yellow lane 
    565.     # lines.)		
    566.     rs_binary = cv2.bitwise_and(s_binary, r_thresh)
    567.  
    568.     ### Combine the possible lane lines with the possible lane line edges ##### 
    569.     # If you show rs_binary visually, you'll see that it is not that different 
    570.     # from this return value. The edges of lane lines are thin lines of pixels.
    571.     self.lane_line_markings = cv2.bitwise_or(rs_binary, sxbinary.astype(
    572.                               np.uint8))	
    573.     return self.lane_line_markings
    574. 		
    575.   def histogram_peak(self):
    576.     """
    577.     Get the left and right peak of the histogram
    579.     Return the x coordinate of the left histogram peak and the right histogram
    580.     peak.
    581.     """
    582.     midpoint = np.int(self.histogram.shape[0]/2)
    583.     leftx_base = np.argmax(self.histogram[:midpoint])
    584.     rightx_base = np.argmax(self.histogram[midpoint:]) + midpoint
    585.  
    586.     # (x coordinate of left peak, x coordinate of right peak)
    587.     return leftx_base, rightx_base
    588. 		
    589.   def overlay_lane_lines(self, plot=False):
    590.     """
    591.     Overlay lane lines on the original frame
    592.     :param: Plot the lane lines if True
    593.     :return: Lane with overlay
    594.     """
    595.     # Generate an image to draw the lane lines on 
    596.     warp_zero = np.zeros_like(self.warped_frame).astype(np.uint8)
    597.     color_warp = np.dstack((warp_zero, warp_zero, warp_zero))		
    598. 		
    599.     # Recast the x and y points into usable format for cv2.fillPoly()
    600.     pts_left = np.array([np.transpose(np.vstack([
    601.                          self.left_fitx, self.ploty]))])
    602.     pts_right = np.array([np.flipud(np.transpose(np.vstack([
    603.                           self.right_fitx, self.ploty])))])
    604.     pts = np.hstack((pts_left, pts_right))
    605. 		
    606.     # Draw lane on the warped blank image
    607.     cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0))
    608.  
    609.     # Warp the blank back to original image space using inverse perspective 
    610.     # matrix (Minv)
    611.     newwarp = cv2.warpPerspective(color_warp, self.inv_transformation_matrix, (
    612.                                   self.orig_frame.shape[
    613.                                   1], self.orig_frame.shape[0]))
    614.     
    615.     # Combine the result with the original image
    616.     result = cv2.addWeighted(self.orig_frame, 1, newwarp, 0.3, 0)
    617. 		
    618.     if plot==True:
    619.      
    620.       # Plot the figures 
    621.       figure, (ax1, ax2) = plt.subplots(2,1) # 2 rows, 1 column
    622.       figure.set_size_inches(10, 10)
    623.       figure.tight_layout(pad=3.0)
    624.       ax1.imshow(cv2.cvtColor(self.orig_frame, cv2.COLOR_BGR2RGB))
    625.       ax2.imshow(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
    626.       ax1.set_title("Original Frame")  
    627.       ax2.set_title("Original Frame With Lane Overlay")
    628.       plt.show()   
    629.  
    630.     return result			
    631. 	
    632.   def perspective_transform(self, frame=None, plot=False):
    633.     """
    634.     Perform the perspective transform.
    635.     :param: frame Current frame
    636.     :param: plot Plot the warped image if True
    637.     :return: Bird's eye view of the current lane
    638.     """
    639.     if frame is None:
    640.       frame = self.lane_line_markings
    641. 			
    642.     # Calculate the transformation matrix
    643.     self.transformation_matrix = cv2.getPerspectiveTransform(
    644.       self.roi_points, self.desired_roi_points)
    645.  
    646.     # Calculate the inverse transformation matrix			
    647.     self.inv_transformation_matrix = cv2.getPerspectiveTransform(
    648.       self.desired_roi_points, self.roi_points)
    649.  
    650.     # Perform the transform using the transformation matrix
    651.     self.warped_frame = cv2.warpPerspective(
    652.       frame, self.transformation_matrix, self.orig_image_size, flags=(
    653.      cv2.INTER_LINEAR))	
    654.  
    655.     # Convert image to binary
    656.     (thresh, binary_warped) = cv2.threshold(
    657.       self.warped_frame, 127, 255, cv2.THRESH_BINARY)			
    658.     self.warped_frame = binary_warped
    659.  
    660.     # Display the perspective transformed (i.e. warped) frame
    661.     if plot == True:
    662.       warped_copy = self.warped_frame.copy()
    663.       warped_plot = cv2.polylines(warped_copy, np.int32([
    664.                     self.desired_roi_points]), True, (147,20,255), 3)
    665.  
    666.       # Display the image
    667.       while(1):
    668.         cv2.imshow('Warped Image', warped_plot)
    669. 			
    670.         # Press any key to stop
    671.         if cv2.waitKey(0):
    672.           break
    673.  
    674.       cv2.destroyAllWindows()	
    675. 			
    676.     return self.warped_frame		
    677. 	
    678.   def plot_roi(self, frame=None, plot=False):
    679.     """
    680.     Plot the region of interest on an image.
    681.     :param: frame The current image frame
    682.     :param: plot Plot the roi image if True
    683.     """
    684.     if plot == False:
    685.       return
    686. 			
    687.     if frame is None:
    688.       frame = self.orig_frame.copy()
    689.  
    690.     # Overlay trapezoid on the frame
    691.     this_image = cv2.polylines(frame, np.int32([
    692.       self.roi_points]), True, (147,20,255), 3)
    693.  
    694.     # Display the image
    695.     while(1):
    696.       cv2.imshow('ROI Image', this_image)
    697. 			
    698.       # Press any key to stop
    699.       if cv2.waitKey(0):
    700.         break
    701.  
    702.     cv2.destroyAllWindows()
    703. 	
    704. def main():
    705.  
    706.   # Load a video
    707.   cap = cv2.VideoCapture(filename)
    708.  
    709.   # Create a VideoWriter object so we can save the video output
    710.   fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    711.   result = cv2.VideoWriter(output_filename,  
    712.                            fourcc, 
    713.                            output_frames_per_second, 
    714.                            file_size) 
    715. 	
    716.   # Process the video
    717.   while cap.isOpened():
    718. 		
    719.     # Capture one frame at a time
    720.     success, frame = cap.read() 
    721. 		
    722.     # Do we have a video frame? If true, proceed.
    723.     if success:
    724. 		
    725.       # Resize the frame
    726.       width = int(frame.shape[1] * scale_ratio)
    727.       height = int(frame.shape[0] * scale_ratio)
    728.       frame = cv2.resize(frame, (width, height))
    729. 			
    730.       # Store the original frame
    731.       original_frame = frame.copy()
    732.  
    733.       # Create a Lane object
    734.       lane_obj = Lane(orig_frame=original_frame)
    735.  
    736.       # Perform thresholding to isolate lane lines
    737.       lane_line_markings = lane_obj.get_line_markings()
    738.  
    739.       # Plot the region of interest on the image
    740.       lane_obj.plot_roi(plot=False)
    741.  
    742.       # Perform the perspective transform to generate a bird's eye view
    743.       # If Plot == True, show image with new region of interest
    744.       warped_frame = lane_obj.perspective_transform(plot=False)
    745.  
    746.       # Generate the image histogram to serve as a starting point
    747.       # for finding lane line pixels
    748.       histogram = lane_obj.calculate_histogram(plot=False)	
    749. 	
    750.       # Find lane line pixels using the sliding window method 
    751.       left_fit, right_fit = lane_obj.get_lane_line_indices_sliding_windows(
    752.         plot=False)
    753.  
    754.       # Fill in the lane line
    755.       lane_obj.get_lane_line_previous_window(left_fit, right_fit, plot=False)
    756. 	
    757.       # Overlay lines on the original frame
    758.       frame_with_lane_lines = lane_obj.overlay_lane_lines(plot=False)
    759.  
    760.       # Calculate lane line curvature (left and right lane lines)
    761.       lane_obj.calculate_curvature(print_to_terminal=False)
    762.  
    763.       # Calculate center offset  																
    764.       lane_obj.calculate_car_position(print_to_terminal=False)
    765. 	
    766.       # Display curvature and center offset on image
    767.       frame_with_lane_lines2 = lane_obj.display_curvature_offset(
    768.         frame=frame_with_lane_lines, plot=False)
    769. 				
    770.       # Write the frame to the output video file
    771.       result.write(frame_with_lane_lines2)
    772. 			
    773.       # Display the frame 
    774.       cv2.imshow("Frame", frame_with_lane_lines2) 	
    775.  
    776.       # Display frame for X milliseconds and check if q key is pressed
    777.       # q == quit
    778.       if cv2.waitKey(25) & 0xFF == ord('q'):
    779.         break
    780. 		
    781.     # No more video frames left
    782.     else:
    783.       break
    784. 			
    785.   # Stop when the video is finished
    786.   cap.release()
    787. 	
    788.   # Release the video recording
    789.   result.release()
    790. 	
    791.   # Close all windows
    792.   cv2.destroyAllWindows() 
    793. 	
    794. main()

     

     

     

     

  • 相关阅读:
    SpringCloud（5）：Ribbon详解
    (附源码)计算机毕业设计Java办公自动化管理系统
    CTF-php代码审计（MD5）
    html菜单的基本制作
    怎样才能批量查询网站的谷歌PR权重？把手教你批量查询网站谷歌PR权重值
    html里面的伪元素是什么？如何操作？
    计算机软件分类、编程知识体系、编程工作岗位
    OpenHarmony Meetup深圳站招募令
    Python 基础 （二）Python变量与基本数据类型
    【数据结构与算法】分治算法的介绍和汉诺塔程序实现
  • 原文地址：https://blog.csdn.net/ZhangRelay/article/details/125435368