Обзорное обнаружение полосы движения является одним из самых важных методов ADAS и недавно получила значительное внимание. В этом проекте мы достигли обнаружения полосы движения с реальным временем от Numpy и многопоточного.
Зависимости:
Python Numpy OpenCV
Как бежать:
Запустите lane_detection.py. Видео по умолчанию – project_video, если вы хотите обработать «fog_video.mp4», измените video_index на 1 в строке 9.
Полный исходный код: импорт Numpy как NP Import CV2 Время импорта из потока импорта потоков из очереди импорта очереди
video_index
Road.Zeros ((720, 1280, 3))
начал
def thresholding_pipeline (img, s_thresh = (90, 255), sxy_thresh = (20, 100)): .copy (img) # 1: преобразовать в цветовое пространство HSV и отделить v -канал .cvtcolor (img, cv2.color_rgb2hls) .astype (np.float) [:,:, 0] [:,:, 1] [:,:, 2]
sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0) # Take the derivative in x
# Absolute x derivative to accentuate lines away from horizontal
abs_sobelx = np.absolute(sobelx)
scaled_sobelx = np.uint8(255 * abs_sobelx / np.max(abs_sobelx))
sxbinary = np.zeros_like(scaled_sobelx)
sxbinary[(scaled_sobelx >= sxy_thresh[0]) &
(scaled_sobelx <= sxy_thresh[1])] = 1
grad_thresh = sxbinary
s_binary = np.zeros_like(s_channel) s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1
combined_binary = np.zeros_like(grad_thresh) combined_binary[(s_binary == 1) | (grad_thresh == 1)] = 1
Вернуть Combined_binary
def oppersive_transform (img, src_mask, dst_mask): img_size = (img.shape [1], img.shape [0]) src.float32 (src_mask) .float32 (dst_mask) .getpersevetransform (src, dst). M, img_size, .inter_linear) return varped_img
def sliding_windows (binary_warped,): .sum (Binary_warped [int (binary_warped.shape [0]/2):,:],)
# 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
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 = []
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]))
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)
return Leathfit_fit, right_fit, левша, левая, правая, правая.
def Project_lanelines (Binary_warped, Orig_img, Leath_fit, Right_fit, DST_MASK, SRC_MASK): Глобальная дорога Глобал начался .linspace (0, binary_warped.shape [0] -1, binary_warped.shape [0]) [0] Плати 2 + LEATE_FIT [1]*PLOTY + LEATE_FIT [2] [0]*PLOTY *2 + right_fit [1]*plety + right_fit [2]
warp_zero = np.zeros_like(binary_warped).astype(np.uint8) color_warp = np.dstack((warp_zero, warp_zero, warp_zero))
pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])
pts_right = np.array(
[np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])
pts = np.hstack((pts_left, pts_right))
cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0)) # Warp the blank back to original image space using inverse perspective matrix (Minv) warped_inv = perspective_transform(color_warp, dst_mask, src_mask) road = warped_inv started = 1
def main_pipeline (input):
if video_index == 0:
image = input
top_left = [540, 460]
top_right = [754, 460]
bottom_right = [1190, 670]
bottom_left = [160, 670]
else:
mtx = np.array([[1.15396467e+03, 0.00000000e+00, 6.69708251e+02], [0.00000000e+00, 1.14802823e+03, 3.85661017e+02],
[0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
dist = np.array([[-2.41026561e-01, -5.30262184e-02, -
1.15775369e-03, -1.27924043e-04, 2.66417032e-02]])
image = cv2.undistort(input, mtx, dist, None, mtx)
top_left = [240, 270]
top_right = [385, 270]
bottom_right = [685, 402]
bottom_left = [0, 402]
src_mask = np.array([[(top_left[0], top_left[1]), (top_right[0], top_right[1]),
(bottom_right[0], bottom_right[1]), (bottom_left[0], bottom_left[1])]], np.int32)
dst_mask = np.array([[(bottom_left[0], 0), (bottom_right[0], 0),
(bottom_right[0], bottom_right[1]), (bottom_left[0], bottom_left[1])]], np.int32)
binary_image = thresholding_pipeline(image, s_thresh=(90, 255))
binary_warped = perspective_transform(binary_image, src_mask, dst_mask)
left_fit, right_fit, lefty, leftx, righty, rightx = sliding_windows(
binary_warped, nwindows=9)
project_lanelines(binary_warped, image, left_fit,
right_fit, dst_mask, src_mask)
Если имя == ‘ Главный ‘: if video_index: .VideoCapture (‘project_video.mp4’) еще: .VideoCapture (‘fog_video.mp4’) класс Mythread (Thread): def init (Self, Q): Нить. init (Self) def Run (Self): В то время как (1): if (не self.q.empty ()): .q.get () main_pipeline (image) () Q.Queue.clear () (Q) thd1.setdaemon (true) thd1.start () while (true): .время () ret, .read ()
if frames_counts % 5 == 0:
q.put(frame)
if started:
frame = cv2.addWeighted(frame, 1, road, 0.5, 0)
cv2.imshow("RealTime_lane_detection", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
frames_counts += 1
cv2.waitKey(12)
finish = time.time()
print('FPS: ' + str(int(1/(finish-start))))
cap.release () cv2.destroyallwindows ()
Ссылка GitHub: https://github.com/nimadorostkar/realtime_lane_detection
Оригинал: “https://dev.to/nimadorostkar/real-time-lane-detection-python-opencv-5nn”