<blockquote>
Ph&aacute;t hiện l&agrave;n đường l&agrave; một nhiệm vụ quan trọng đối với việc ph&aacute;t triển hệ thống &ocirc;t&ocirc; tự l&aacute;i n&oacute;i ri&ecirc;ng v&agrave; đối với thị gi&aacute;c m&aacute;y t&iacute;nh n&oacute;i chung. Trong b&agrave;i viết n&agrave;y, ch&uacute;ng ta sẽ x&acirc;y dựng một model để ph&aacute;t hiện c&aacute;c vạch kẻ l&agrave;n đường trong thời gian thực bằng c&aacute;ch sử dụng thư viện openCV. Để ph&aacute;t hiện l&agrave;n đường, ch&uacute;ng ta phải ph&aacute;t hiện c&aacute;c vạch trắng ở cả hai b&ecirc;n tr&ecirc;n l&agrave;n đường.
</blockquote>
<h3 class="fittexted_for_content_h3" style="text-align: justify;">Frame Masking v&agrave; Hough Line Transformation</h3>
Để nhận biết c&aacute;c vạch trắng tr&ecirc;n l&agrave;n đường, trước ti&ecirc;n ch&uacute;ng ta cần che phần c&ograve;n lại của frame, ch&uacute;ng ta l&agrave;m điều n&agrave;y bằng c&aacute;ch sử dụng&nbsp;frame masking. Frame&nbsp;kh&ocirc;ng c&oacute; g&igrave; kh&aacute;c ngo&agrave;i một mảng numpy c&aacute;c gi&aacute; trị pixel của h&igrave;nh ảnh v&agrave; để che đi c&aacute;c pixel kh&ocirc;ng cần thiết ch&uacute;ng ta chỉ cần cập nhật c&aacute;c pixel đ&oacute; bằng 0 trong mảng numpy.
Sau khi thực hiện, ch&uacute;ng ta&nbsp; cần phải ph&aacute;t hiện c&aacute;c vạch đường.&nbsp;Kỹ thuật được sử dụng để ph&aacute;t hiện c&aacute;c h&igrave;nh dạng to&aacute;n học như thế n&agrave;y được gọi l&agrave; Hough Transform.&nbsp;Hough&nbsp;Transform c&oacute; thể ph&aacute;t hiện c&aacute;c h&igrave;nh dạng như h&igrave;nh chữ nhật, h&igrave;nh tr&ograve;n, h&igrave;nh tam gi&aacute;c v&agrave; đường thẳng.
<h3 style="text-align: justify;">C&aacute;c Bước X&acirc;y Dựng M&ocirc; H&igrave;nh Ph&aacute;t Hiện L&agrave;n Đường</h3>
Trước khi bắt đầu bạn c&oacute; thể tải xuống source code: <a href="https://drive.google.com/drive/folders/1Oqak5rV7h2xvc5x4o9JzaBXfsg80oRHb?usp=sharing" target="_blank" rel="noopener">Detect Road Lane</a>
Bước 1: import c&aacute;c thư viện cần thiết
<pre><code class="python">import matplotlib.pyplot as plt

import numpy as np
import cv2
import os
import matplotlib.image as mpimg
from moviepy.editor import VideoFileClip
import math</code></pre>
Bước 2:&nbsp; &Aacute;p dụng frame masking v&agrave; t&igrave;m c&aacute;c khu vực cần quan t&acirc;m
<pre><code class="python">def interested_region(img, vertices):
 if len(img.shape) &gt; 2: 
 mask_color_ignore = (255,) * img.shape[2]
 else:
 mask_color_ignore = 255
 
 cv2.fillPoly(np.zeros_like(img), vertices, mask_color_ignore)
 return cv2.bitwise_and(img, np.zeros_like(img))</code></pre>
Bước 3: Chuyển đổi c&aacute;c pixel th&agrave;nh 1 line trong&nbsp;&nbsp;<a href="https://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm" target="_blank" rel="noopener">Hough Transform space</a>
<pre><code class="python">def hough_lines(img, rho, theta, threshold, min_line_len, max_line_gap):
 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)
 lines_drawn(line_img,lines)
 return line_img</code></pre>
Bước 4: Tạo 2 lines trong mỗi frame sau khi&nbsp;Hough transform
<pre><code class="python">def lines_drawn(img, lines, color=[255, 0, 0], thickness=6):
 global cache
 global first_frame
 slope_l, slope_r = [],[]
 lane_l,lane_r = [],[]

 &alpha; =0.2 
 for line in lines:
 for x1,y1,x2,y2 in line:
 slope = (y2-y1)/(x2-x1)
 if slope &gt; 0.4:
 slope_r.append(slope)
 lane_r.append(line)
 elif slope &lt; -0.4: slope_l.append(slope) lane_l.append(line) img.shape[0] = min(y1,y2,img.shape[0]) if((len(lane_l) == 0) or (len(lane_r) == 0)): print ('no lane detected') return 1 slope_mean_l = np.mean(slope_l,axis =0) slope_mean_r = np.mean(slope_r,axis =0) mean_l = np.mean(np.array(lane_l),axis=0) mean_r = np.mean(np.array(lane_r),axis=0) if ((slope_mean_r == 0) or (slope_mean_l == 0 )): print('dividing by zero') return 1 x1_l = int((img.shape[0] - mean_l[0][1] - (slope_mean_l * mean_l[0][0]))/slope_mean_l) x2_l = int((img.shape[0] - mean_l[0][1] - (slope_mean_l * mean_l[0][0]))/slope_mean_l) x1_r = int((img.shape[0] - mean_r[0][1] - (slope_mean_r * mean_r[0][0]))/slope_mean_r) x2_r = int((img.shape[0] - mean_r[0][1] - (slope_mean_r * mean_r[0][0]))/slope_mean_r) if x1_l &gt; x1_r:
 x1_l = int((x1_l+x1_r)/2)
 x1_r = x1_l
 y1_l = int((slope_mean_l * x1_l ) + mean_l[0][1] - (slope_mean_l * mean_l[0][0]))
 y1_r = int((slope_mean_r * x1_r ) + mean_r[0][1] - (slope_mean_r * mean_r[0][0]))
 y2_l = int((slope_mean_l * x2_l ) + mean_l[0][1] - (slope_mean_l * mean_l[0][0]))
 y2_r = int((slope_mean_r * x2_r ) + mean_r[0][1] - (slope_mean_r * mean_r[0][0]))
 else:
 y1_l = img.shape[0]
 y2_l = img.shape[0]
 y1_r = img.shape[0]
 y2_r = img.shape[0]
 
 present_frame = np.array([x1_l,y1_l,x2_l,y2_l,x1_r,y1_r,x2_r,y2_r],dtype ="float32")
 
 if first_frame == 1:
 next_frame = present_frame 
 first_frame = 0 
 else :
 prev_frame = cache
 next_frame = (1-&alpha;)*prev_frame+&alpha;*present_frame
 
 cv2.line(img, (int(next_frame[0]), int(next_frame[1])), (int(next_frame[2]),int(next_frame[3])), color, thickness)
 cv2.line(img, (int(next_frame[4]), int(next_frame[5])), (int(next_frame[6]),int(next_frame[7])), color, thickness)
 
 cache = next_frame</code></pre>
Bước 5: Xử l&yacute; từng frame của video để nhận biết l&agrave;n đường
<pre><code class="python">def weighted_img(img, initial_img, &alpha;=0.8, &beta;=1., &lambda;=0.):
 return cv2.addWeighted(initial_img, &alpha;, img, &beta;, &lambda;)


def process_image(image):

 global first_frame

 gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 img_hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)


 lower_yellow = np.array([20, 100, 100], dtype = "uint8")
 upper_yellow = np.array([30, 255, 255], dtype="uint8")

 mask_yellow = cv2.inRange(img_hsv, lower_yellow, upper_yellow)
 mask_white = cv2.inRange(gray_image, 200, 255)
 mask_yw = cv2.bitwise_or(mask_white, mask_yellow)
 mask_yw_image = cv2.bitwise_and(gray_image, mask_yw)

 gauss_gray= cv2.GaussianBlur(mask_yw_image, (5, 5), 0)

 canny_edges=cv2.Canny(gauss_gray, 50, 150)

 imshape = image.shape
 lower_left = [imshape[1]/9,imshape[0]]
 lower_right = [imshape[1]-imshape[1]/9,imshape[0]]
 top_left = [imshape[1]/2-imshape[1]/8,imshape[0]/2+imshape[0]/10]
 top_right = [imshape[1]/2+imshape[1]/8,imshape[0]/2+imshape[0]/10]
 vertices = [np.array([lower_left,top_left,top_right,lower_right],dtype=np.int32)]
 roi_image = interested_region(canny_edges, vertices)

 theta = np.pi/180

 line_image = hough_lines(roi_image, 4, theta, 30, 100, 180)
 result = weighted_img(line_image, image, &alpha;=0.8, &beta;=1., &lambda;=0.)
 return result</code></pre>
Bước 6:&nbsp;Cắt video đầu v&agrave;o th&agrave;nh c&aacute;c frames v&agrave; nhận kết quả l&agrave; video đầu ra
<pre><code class="python">first_frame = 1
white_output = '__path_to_output_file__'
clip1 = VideoFileClip("__path_to_input_file__")
white_clip = clip1.fl_image(process_image)
white_clip.write_videofile(white_output, audio=False)</code></pre>
<h3 style="text-align: justify;">Kết Luận</h3>
Trong project n&agrave;y ch&uacute;ng ta đ&atilde; học được c&aacute;ch x&acirc;y dựng m&ocirc; h&igrave;nh nhận biết l&agrave;n đường sử dụng openCV. Biết c&aacute;ch&nbsp; Frame Masking v&agrave; Hough Transfor.&nbsp;Hi vọng bạn th&agrave;nh c&ocirc;ng với project n&agrave;y, h&atilde;y tiếp tục truy cập v&agrave;o&nbsp;<a href="https://tek4.vn/" target="_blank" rel="noopener">Tek4.vn</a>&nbsp;để thực h&agrave;nh c&aacute;c project về Deep Learning th&uacute; vị kh&aacute;c nh&eacute;!
&nbsp;
<hr />
Fanpage Facebook:&nbsp;<a href="https://www.facebook.com/tek4.vn/">TEK4.VN</a>&nbsp;
Tham gia cộng đồng để chia sẻ, trao đổi v&agrave; thảo luận:&nbsp;<a href="https://www.facebook.com/groups/tek4.vn/">TEK4.VN - Học Lập Tr&igrave;nh Miễn Ph&iacute;</a>

Admin

Phát Hiện Làn Đường Cho Ôtô Tự Lái – Computer Vision Project

Cùng tác giả

Admin

Có liên quan