TRƯỜNG ĐẠI HỌC HẢNG HẢI VIỆT NAM

KHOA CÔNG NGHỆ THÔNG TIN

-----***-----

BÁO CÁO BÀI TẬP LỚN

HỌC PHẦN “NHẬN DIỆN VÀ XỬ LÝ ẢNH”

Đề tài:

Xây dựng chương trình nhận dạng biển báo giao thông

GVHD: TS. Nguyễn Hữu Tuân

Sinh viên thực hiện: Khổng Đỗ Hạ Vũ - 87018

Hải Phòng, tháng năm 2023

 LỜI NÓI ĐẦU
Với công nghệ ngày một phát triển, ứng dụng công nghệ vào cuộc sống thường
nhật hay công việc đang là xu hướng phát triển của xã hội hiện nây. Điều này vừa
giúp các công việc được ứng dụng sẽ vận hành chính xác ,trơn tru vừa đảm bảo sự
an toàn , tính chính xác cao cho các công việc với những đặc thù riêng.
Một đất nước phát triển luôn đi kèm với sự phát triển về kỹ thuật trong đó có thể
kể đến việc sản xuất ô tô nội địa. VinFast hiện đang rất thành công trong việc sản
xuất ô tô với chính sách mới tiến tới sản xuất ô tô điện và theo xu hướng công nghệ
ô tô tự lái khả năng cao sẽ là bước phát triển tiếp theo của tập đoàn này.
Một trong những điều quan trọng để có thể sản xuất ô tô tự lái chính là khả năng
nhận diện và hiểu được các quy tắc giao thông – Hay nói cách khác là khả năng
nhận diên biển báo giao thông.Đó là ứng dụng cho phép máy tính tự động xác định
và nhận dạng các vật thể qua hình ảnh hay khung hình của video. Để làm được
điều này cần có một cơ sở dữ liệu về biển báo giao thông, khi ứng dụng quét hình
ảnh sẽ đối chiếu với cơ sở dữ liệu để đưa ra kết quả và nhận dạng hình ảnh đó.
Xuất phát từ việc đó em đã nghiên cứu và tham khảo để hoàn thành bài tập lớn
“Xây dựng chương trình nhận dang biển báo giao thông”

2
Mục lục
CHƯƠNG I.GIỚI THIỆU BÀI TOÁN.........................................................................4
1.1 Đặt vấn đề...........................................................................................................4
1.2 Mục tiêu và nhiệm vụ nghiên cứu.......................................................................4
1.3 Phương tiện công cụ sử dụng..............................................................................4
1.4 Phương pháp sử dụng..........................................................................................4
CHƯƠNG II.CÁC THUẬT TOÁN VÀ KHÁI NIỆM ĐƯỢC SỬ DỤNG.................5
2.1 Thuật toán Gauss.................................................................................................5
2.2 Toán tử Laplacian...............................................................................................5
2.3 Ảnh nhị phân (Binary image)..............................................................................5
2.4 Ảnh xám (Gray image)........................................................................................5
2.5 Biến đổi Hough (Hough Transform)...................................................................5
2.6 Giải thuật Canny.................................................................................................6
CHƯƠNG III : XÂY DỰNG CHƯƠNG TRÌNH........................................................7
3.1 Khái quát bài toán...............................................................................................7
3.2 Các bước thực hiện bài toán................................................................................7
3.3 Các hàm tiền xử lý ảnh........................................................................................8
3.3.1 Hàm constrastLimit:.....................................................................................8
3.3.2 Hàm LaplacianOfGaussian..........................................................................9
3.3.3 Hàm binarization..........................................................................................9
3.3.4 Hàm preprocess_image................................................................................9
3.3.5 Hàm removeSmallComponents.................................................................10
3.3.6 Hàm FindContour......................................................................................10
3.3.7 Hàm contourIsSign....................................................................................10
3.3.8 Các hàm crop sign......................................................................................11
3.3.9 Hàm tìm kiếm biển báo..............................................................................12
3.3.10 Hàm localization......................................................................................13
3.3.11 Hàm remove_line.....................................................................................14
3.3.12 Hàm remove_other_color.........................................................................15
3.3.13 Hàm main()..............................................................................................16
3
CHƯƠNG IV: KẾT QUẢ CHẠY CHƯƠNG TRÌNH...............................................22
CHƯƠNG V: ĐÁNH GIÁ VỀ CHƯƠNG TRÌNH VÀ KẾT LUẬN........................25
Ưu điểm:.................................................................................................................25
Nhược điểm:............................................................................................................25
Hướng phát triển trong tương lai............................................................................25
Lời kết.....................................................................................................................25

4
 CHƯƠNG I.GIỚI THIỆU BÀI TOÁN
1.1 Đặt vấn đề
Với việc ứng dụng công nghệ thông tin để giải quyết các vấn đề trong giao thông là
một vấn đề thiết yếu và quan trọng. Việc xây dựng hệ thống giao thông thông minh
ở các xe tự động là vấn đề được quan tâm và phát triển trong và cả ngoài nước.
Sự phát triển thường xuyên của công nghệ trong sản xuất ô tô với những cải tiến
liên tục cho các dòng xe mới thì việc có một hệ thống nhận diện biển báo là một sự
cải tiện nên có và được quan tâm đảm bảo sự chính xác trong xử lý và an toàn
trong giao thông .
1.2 Mục tiêu và nhiệm vụ nghiên cứu
Mục tiêu: tạo ra một hệ thống có thể nhận dạng được cơ bản một số biển báo giao
thông
Nhiệm vụ nghiên cứu:
Nghiên cứu tổng quan về xử lý ảnh
Nghiên cứu, phân tích các phương pháp nhận dạng, xử lý hình ảnh biển báo giao
thông
Tìm hiểu các biển báo giao thông
Thu thập dữ liệu các biển báo cho cơ sở dữ liệu hình ảnh để nhận dang biển báo
giao thông
1.3 Phương tiện công cụ sử dụng
Thư viện sử dụng: OpenCV
Ngôn ngữ lập trình: Python
Phần mềm sử dụng : Anaconda-Spyder
1.4 Phương pháp sử dụng

5
 CHƯƠNG II.CÁC THUẬT TOÁN VÀ KHÁI NIỆM ĐƯỢC
SỬ DỤNG
2.1 Thuật toán Gauss
Gaussian blur (làm mờ/mịn Gaussian) là kết quả của việc làm mờ hình ảnh bởi một
hàm Gaussian.
Kỹ thuật này được sử dụng để giảm nhiễu ảnh và các chi tiết. Hiệu ứng hình ảnh
của kỹ thuật Gaussian tương tự như việc nhìn một hình ảnh qua màn hình mờ.
Trong thị giác máy tính, Gaussian được sử dụng để tăng cường hình ảnh ở các quy
mô khác nhau hoặc như một kỹ thuật tăng cường dữ liệu trong học sâu.

2.2 Toán tử Laplacian

Là một toán tử vi phân, đặc biệt trong các toán tử elliptic, với nhiều áp dụng.
Trong vật lý, nó được sử dụng trong mô tả của quá trình truyền sóng, quá trình
truyền nhiệt.
Dựa vào toán tử Laplacian, ảnh sắc nét sẽ thu được bằng cách lấy ảnh gốc trừ đi
Laplacian của nó
2.3 Ảnh nhị phân (Binary image)
Ảnh nhị phân (hay còn gọi là binary image trong tiếng Anh) là ảnh đen trắng chỉ có
2 giá trị là 0 và 255 (miền số nguyên) hoặc 0 và 1 (miền số thực / đối với ROI).
2.4 Ảnh xám (Gray image)
Ảnh xám hay còn gọi là ảnh đơn sắc (monochromatic). Ảnh 8 mức xám mỗi điểm
ảnh sẽ có giá trị nằm trong đoạn [0-7], ảnh 256 mức xám mỗi điểm ảnh sẽ có giá trị
nằm trong đoạn [0-255].
Giá trị của điểm ảnh bằng 0 đại diện cho điểm ảnh tối (đen), giá trị điểm ảnh lơn
nhất đại diện cho điểm ảnh sáng (trắng).

6
 2.5 Biến đổi Hough (Hough Transform)
Là một kỹ thuật phổ biến để phát hiện bất kỳ hình dạng nào nếu có thể biểu diễn
hình dạng đó dưới dạng toán học. Có thể phát hiện hình dạng ngay cả khi nó bị
hỏng hoặc bị bóp méo một chút
2.6 Giải thuật Canny
Gồm 4 bước:
Giảm nhiễu: Làm mờ ảnh, giảm nhiễu
Tính Gradient và hướng gradient

Non-maximum Suppression (viết tắt NMS): loại bỏ các pixel ở vị trí không phải
cực đại toàn cục
Ngưỡng kép (Double threshold)
Theo dõi cạnh bằng độ trễ (Edge Tracking by Hysteresis)

7
 CHƯƠNG III : XÂY DỰNG CHƯƠNG TRÌNH
3.1 Khái quát bài toán
Bài toán nhận dang biển báo giao thông trải qua các bước sau:
Thông qua nguồn dữ liệu cụ thể là video được ghi lại , hệ thống sẽ xác định các
biển báo trong khung hình và dối chiếu với cơ sở dữ liệu được lưu sẵn của hệ
thống và xác định xem hình ảnh nhận được trong đó có phải biển báo giao thông
không. Sau khi nhận dang được đó là biển báo giao thông , hệ thống sẽ xử lý, nhận
dang và đưa thông tin là tên của biển báo giao thông
3.2 Các bước thực hiện bài toán
Thu nhập các ảnh biển báo giao thông
Tạo 1 folder “Dataset” và đưa vào CSDL hình ảnh gồm các biển báo gồm các biển
báo sau đây

Huấn luyện model phân loại biển bảo và kiểm thử

8
 Kết quả training

Tạo 1 hàm clean_images() để xóa các file khởi chạy trước đó

def clean_images():
file_list = os.listdir('./')
for file_name in file_list:
if '.png' in file_name:
os.remove(file_name)
3.3 Các hàm tiền xử lý ảnh
3.3.1 Hàm constrastLimit:
def constrastLimit(image):
img_hist_equalized = cv2.cvtColor(image, cv2.COLOR_BGR2YCrCb)
channels = cv2.split(img_hist_equalized)
channels[0] = cv2.equalizeHist(channels[0])
img_hist_equalized = cv2.merge(channels)
img_hist_equalized = cv2.cvtColor(img_hist_equalized,
cv2.COLOR_YCrCb2BGR)
return img_hist_equalized
9
Đầu tiên chuyển đổi từ ảnh sang định dạng YCrCb, thực hiện chia lấy các kênh
màu của ảnh , thực hiện cần bằng sáng bằng equalizeHist , hàm cv2.merge lấy từng
kênh màu của ảnh và hợp nhất thành một ảnh để chứa nhiều channel – multi
channel image. Sau đó tiếp tục chuyển đổi ảnh về lại RGB và trả lại ảnh ở định
dang RGB

3.3.2 Hàm LaplacianOfGaussian

def LaplacianOfGaussian(image):
LoG_image = cv2.GaussianBlur(image, (3,3), 0)
gray = cv2.cvtColor( LoG_image, cv2.COLOR_BGR2GRAY)
LoG_image = cv2.Laplacian( gray, cv2.CV_8U,3,3,2)
LoG_image = cv2.convertScaleAbs(LoG_image)
return LoG_image

Hàm sẽ sử dụng GaussiaanBlur làm mịn ảnh được cho vào , sao đó chuyển ảnh
được làm mịn sang ảnh xám bằng cv2.cvtColor rồi tiếp tục dùng hàm
cv2.Laplacian để làm giảm thiệu độ nhiễu của ảnh. Sau cùng dùng
cv2.convertScaleAbs chia tỷ lệ,lấy giá trị tuyệt đối, chuyển đổi thành loại 8-bit

3.3.3 Hàm binarization

def binarization(image):
thresh = cv2.threshold(image,32,255,cv2.THRESH_BINARY)[1]
return thresh
Hàm sử dụng threshold phân ngưỡng và sinh ra hình ảnh nhị phân

3.3.4 Hàm preprocess_image

def preprocess_image(image):
image = constrastLimit(image)
image = LaplacianOfGaussian(image)
image = binarization(image)
return image
Sau cùng ta sử dụng cả 3 hàm trên để xử lý ảnh và trả lại ảnh sau khi được xử lý

10
 3.3.5 Hàm removeSmallComponents
def removeSmallComponents(image, threshold):
nb_components, output, stats, centroids =
cv2.connectedComponentsWithStats(image, connectivity=8)
sizes = stats[1:, -1]; nb_components = nb_components - 1

img2 = np.zeros((output.shape),dtype = np.uint8)

for i in range(0, nb_components):
if sizes[i] >= threshold:
img2[output == i + 1] = 255
return img2
Hàm sẽ tìm các điểm trắng trong bức ảnh của bạn sau đó với mỗi thành phần đó
chạy vòng lặp và chỉ giữ lại các điểm trên ngưỡng threshold
3.3.6 Hàm FindContour
def findContour(image):
cnts = cv2.findContours(image, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE )
cnts = cnts[0] if imutils.is_cv2() else cnts[1]
return cnts
Hàm tìm các đường bao của ảnh nhị phân sử dụng hàm cv2.findContour để tìm các
đường bao và trả lại các đường bao đó

3.3.7 Hàm contourIsSign

def contourIsSign(perimeter, centroid, threshold):
# perimeter, centroid, threshold
# # Compute signature of contour
result=[]
for p in perimeter:
p = p[0]
distance = sqrt((p[0] - centroid[0])**2 + (p[1] - centroid[1])**2)
result.append(distance)
max_value = max(result)

11
 signature = [float(dist) / max_value for dist in result ]
# Check signature of contour.
temp = sum((1 - s) for s in signature)
temp = temp / len(signature)
if temp < threshold: # is the sign
return True, max_value + 2
else: # is not the sign
return False, max_value + 2
Hàm sẽ tính toán dựa vào tâm vầ chu vi và ngưỡng threshold , tạo một list result
nhập thêm kết quả của mỗi distance theo công thức , tính giá trị max_value bằng
giá trị lớn nhất của list result. Tạo list signature với mỗi giá trị bên trong list bằng
khoảng cách chia cho giá trị lớn nhất của list kết quả . Tạo biến temp bằng tổng
của 1 – s với mỗi s là biến trong list signature. Sau đó gán temp = temp chia cho số
lượng biến trong signature . Nếu như nhỏ hơn thì trả về kết quả đúng tức là biển
báo và max_value +2 ngược lại nếu lớn hơn trả về kết quả sai tức ko phải biển báo
và max_value +2
3.3.8 Các hàm crop sign
def cropContour(image, center, max_distance):
width = image.shape[1]
height = image.shape[0]
top = max([int(center[0] - max_distance), 0])
bottom = min([int(center[0] + max_distance + 1), height-1])
left = max([int(center[1] - max_distance), 0])
right = min([int(center[1] + max_distance+1), width-1])
print(left, right, top, bottom)
return image[left:right, top:bottom]

def cropSign(image, coordinate):

width = image.shape[1]
height = image.shape[0]
top = max([int(coordinate[0][1]), 0])
bottom = min([int(coordinate[1][1]), height-1])
left = max([int(coordinate[0][0]), 0])
12
 right = min([int(coordinate[1][0]), width-1])
#print(top,left,bottom,right)
return image[top:bottom,left:right]

Các hàm này sẽ cắt phần ảnh biển báo và lưu lại

3.3.9 Hàm tìm kiếm biển báo

def findLargestSign(image, contours, threshold, distance_theshold):
max_distance = 0
coordinate = None
sign = None
for c in contours:
M = cv2.moments(c)
if M["m00"] == 0:
continue
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
is_sign, distance = contourIsSign(c, [cX, cY], 1-threshold)
if is_sign and distance > max_distance and distance > distance_theshold:
max_distance = distance
coordinate = np.reshape(c, [-1,2])
left, top = np.amin(coordinate, axis=0)
right, bottom = np.amax(coordinate, axis = 0)
coordinate = [(left-2,top-2),(right+3,bottom+1)]
sign = cropSign(image,coordinate)
return sign, coordinate

def findSigns(image, contours, threshold, distance_theshold):

signs = []
coordinates = []
for c in contours:
13
 # compute the center of the contour
M = cv2.moments(c)
if M["m00"] == 0:
continue
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
is_sign, max_distance = contourIsSign(c, [cX, cY], 1-threshold)
if is_sign and max_distance > distance_theshold:
sign = cropContour(image, [cX, cY], max_distance)
signs.append(sign)
coordinate = np.reshape(c, [-1,2])
top, left = np.amin(coordinate, axis=0)
right, bottom = np.amax(coordinate, axis = 0)
coordinates.append([(top-2,left-2),(right+1,bottom+1)])
return signs, coordinates

3.3.10 Hàm localization

def localization(image, min_size_components, similitary_contour_with_circle,
model, count, current_sign_type):
original_image = image.copy()
binary_image = preprocess_image(image)

binary_image = removeSmallComponents(binary_image,
min_size_components)

binary_image = cv2.bitwise_and(binary_image,binary_image,
mask=remove_other_color(image))

#binary_image = remove_line(binary_image)

cv2.imshow('BINARY IMAGE', binary_image)

contours = findContour(binary_image)

14
 #signs, coordinates = findSigns(image, contours, similitary_contour_with_circle,
15)
sign, coordinate = findLargestSign(original_image, contours,
similitary_contour_with_circle, 15)

text = ""
sign_type = -1
i=0

if sign is not None:

sign_type = getLabel(model, sign)
sign_type = sign_type if sign_type <= 8 else 8
text = SIGNS[sign_type]
cv2.imwrite(str(count)+'_'+text+'.png', sign)

if sign_type > 0 and sign_type != current_sign_type:

cv2.rectangle(original_image, coordinate[0],coordinate[1], (0, 255, 0), 1)
font = cv2.FONT_HERSHEY_PLAIN
cv2.putText(original_image,text,(coordinate[0][0], coordinate[0][1] -15), font,
1,(0,0,255),2,cv2.LINE_4)
return coordinate, original_image, sign_type, text

Hàm này sẽ xử lý dữ liệu ảnh đầu vào và trình chiếu ra ảnh nhị phân sau đó xác
định biển báo nhận được là biển báo gì

3.3.11 Hàm remove_line

def remove_line(img):
gray = img.copy()
edges = cv2.Canny(gray,50,150,apertureSize = 3)
minLineLength = 5
maxLineGap = 3
lines = cv2.HoughLinesP(edges,1,np.pi/180,15,minLineLength,maxLineGap)

15
 mask = np.ones(img.shape[:2], dtype="uint8") * 255
if lines is not None:
for line in lines:
for x1,y1,x2,y2 in line:
cv2.line(mask,(x1,y1),(x2,y2),(0,0,0),2)
return cv2.bitwise_and(img, img, mask=mask)

Sử dụng biến đổi Hough thể hiện hình ảnh dưới dạng toán học sử dụng
cv2.bitwise_and qua đó loại bỏ viền
3.3.12 Hàm remove_other_color
def remove_other_color(img):
frame = cv2.GaussianBlur(img, (3,3), 0)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# define range of blue color in HSV
lower_blue = np.array([100,128,0])
upper_blue = np.array([215,255,255])
# Threshold the HSV image to get only blue colors
mask_blue = cv2.inRange(hsv, lower_blue, upper_blue)

lower_white = np.array([0,0,128], dtype=np.uint8)

upper_white = np.array([255,255,255], dtype=np.uint8)
# Threshold the HSV image to get only blue colors
mask_white = cv2.inRange(hsv, lower_white, upper_white)

lower_black = np.array([0,0,0], dtype=np.uint8)

upper_black = np.array([170,150,50], dtype=np.uint8)

mask_black = cv2.inRange(hsv, lower_black, upper_black)

mask_1 = cv2.bitwise_or(mask_blue, mask_white)

mask = cv2.bitwise_or(mask_1, mask_black)
# Bitwise-AND mask and original image
16
 #res = cv2.bitwise_and(frame,frame, mask= mask)
return mask

Hàm dùng gaussianBlur để làm mịn ảnh sau đó chuyển định dạng ảnh sang không
gian màu HSV, định dạng vùng xanh của ảnh trong không gian màu , chỉnh
ngưỡng để lấy vùng xanh của ảnh, loại bỏ các màu sắc khác

3.3.13 Hàm main()

def main(args):
#Clean previous image
clean_images()
#Training phase
model = training()

vidcap = cv2.VideoCapture(args.file_name)

fps = vidcap.get(cv2.CAP_PROP_FPS)
width = vidcap.get(3) # float
height = vidcap.get(4) # float

# Define the codec and create VideoWriter object

fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi',fourcc, fps , (640,480))

# initialize the termination criteria for cam shift, indicating

# a maximum of ten iterations or movement by a least one pixel
# along with the bounding box of the ROI
termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
10, 1)
roiBox = None
roiHist = None

17
 success = True
similitary_contour_with_circle = 0.65 # parameter
count = 0
current_sign = None
current_text = ""
current_size = 0
sign_count = 0
coordinates = []
position = []
file = open("Output.txt", "w")
while True:
success,frame = vidcap.read()
if not success:
print("FINISHED")
break
width = frame.shape[1]
height = frame.shape[0]
#frame = cv2.resize(frame, (640,int(height/(width/640))))
frame = cv2.resize(frame, (640,480))

print("Frame:{}".format(count))
#image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
coordinate, image, sign_type, text = localization(frame,
args.min_size_components, args.similitary_contour_with_circle, model, count,
current_sign)
if coordinate is not None:
cv2.rectangle(image, coordinate[0],coordinate[1], (255, 255, 255), 1)
print("Sign:{}".format(sign_type))
if sign_type > 0 and (not current_sign or sign_type != current_sign):
current_sign = sign_type
current_text = text
top = int(coordinate[0][1]*1.05)
18
 left = int(coordinate[0][0]*1.05)
bottom = int(coordinate[1][1]*0.95)
right = int(coordinate[1][0]*0.95)

position = [count, sign_type if sign_type <= 8 else 8, coordinate[0][0],

coordinate[0][1], coordinate[1][0], coordinate[1][1]]
cv2.rectangle(image, coordinate[0],coordinate[1], (0, 255, 0), 1)
font = cv2.FONT_HERSHEY_PLAIN
cv2.putText(image,text,(coordinate[0][0], coordinate[0][1] -15), font, 1,
(0,0,255),2,cv2.LINE_4)

tl = [left, top]
br = [right,bottom]
print(tl, br)
current_size = math.sqrt(math.pow((tl[0]-br[0]),2) + math.pow((tl[1]-
br[1]),2))
# grab the ROI for the bounding box and convert it
# to the HSV color space
roi = frame[tl[1]:br[1], tl[0]:br[0]]
roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
#roi = cv2.cvtColor(roi, cv2.COLOR_BGR2LAB)

# compute a HSV histogram for the ROI and store the

# bounding box
roiHist = cv2.calcHist([roi], [0], None, [16], [0, 180])
roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX)
roiBox = (tl[0], tl[1], br[0], br[1])

elif current_sign:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1)

19
 # apply cam shift to the back projection, convert the
# points to a bounding box, and then draw them
(r, roiBox) = cv2.CamShift(backProj, roiBox, termination)
pts = np.int0(cv2.boxPoints(r))
s = pts.sum(axis = 1)
tl = pts[np.argmin(s)]
br = pts[np.argmax(s)]
size = math.sqrt(pow((tl[0]-br[0]),2) +pow((tl[1]-br[1]),2))
print(size)

if current_size < 1 or size < 1 or size / current_size > 30 or

math.fabs((tl[0]-br[0])/(tl[1]-br[1])) > 2 or math.fabs((tl[0]-br[0])/(tl[1]-br[1])) <
0.5:
current_sign = None
print("Stop tracking")
else:
current_size = size

if sign_type > 0:
top = int(coordinate[0][1])
left = int(coordinate[0][0])
bottom = int(coordinate[1][1])
right = int(coordinate[1][0])

position = [count, sign_type if sign_type <= 8 else 8, left, top, right,

bottom]
cv2.rectangle(image, coordinate[0],coordinate[1], (0, 255, 0), 1)
font = cv2.FONT_HERSHEY_PLAIN
cv2.putText(image,text,(coordinate[0][0], coordinate[0][1] -15), font, 1,
(0,0,255),2,cv2.LINE_4)
elif current_sign:

20
 position = [count, sign_type if sign_type <= 8 else 8, tl[0], tl[1], br[0],
br[1]]
cv2.rectangle(image, (tl[0], tl[1]),(br[0], br[1]), (0, 255, 0), 1)
font = cv2.FONT_HERSHEY_PLAIN
cv2.putText(image,current_text,(tl[0], tl[1] -15), font, 1,
(0,0,255),2,cv2.LINE_4)

if current_sign:
sign_count += 1
coordinates.append(position)

cv2.imshow('Result', image)
count = count + 1
#Write to video
out.write(image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
file.write("{}".format(sign_count))
for pos in coordinates:
file.write("\n{} {} {} {} {} {}".format(pos[0],pos[1],pos[2],pos[3],pos[4],
pos[5]))
print("Finish {} frames".format(count))
file.close()
return

if __name__ == '__main__':
parser = argparse.ArgumentParser(description="NLP Assignment Command
Line")

parser.add_argument(
'--file_name',

21
 default= "./MVI_1049.avi",
help= "Video to be analyzed"
)

parser.add_argument(
'--min_size_components',
type = int,
default= 300,
help= "Min size component to be reserved"
)

parser.add_argument(
'--similitary_contour_with_circle',
type = float,
default= 0.65,
help= "Similitary to a circle"
)

args = parser.parse_args()
main(args)

Hàm thực hiện chính sẽ training xử lý dữ ảnh dầu vào từ video so sánh đối chiếu
với ảnh trong cơ sở dữ liệu và trình chiếu kết quả ra gồm video output.avi là kết
quả nhận dạng các biển báo có trong video . Đồng thời in ra kết quả training ảnh

22
 CHƯƠNG IV: KẾT QUẢ CHẠY CHƯƠNG TRÌNH

Sau khi chạy video đầu vào sẽ xuất ra video output với kết quả nhận dạng các ảnh
sau

23
24
25
 CHƯƠNG V: ĐÁNH GIÁ VỀ CHƯƠNG TRÌNH VÀ KẾT
LUẬN
Ưu điểm:
 Nhận dạng được một số biển báo cơ bản, đáp ứng cơ bản yêu cầu bài toán đề
ra
 Độ chính xác với các biển báo trong cơ sở dữ liệu là tương đối ổn
Nhược điểm:
 Hiện tại chương trình mới chỉ nhận dạng được số ít biển báo , thuật toán mới
chỉ có thể xác định các biển báo hình tròn
 Sự chính xác của thuật toán vẫn chưa cao , vẫn còn khiếm khuyết và nhầm
lẫn
 Khả năng nhận diện còn phụ thuộc vào ánh sáng và môi trường xung quanh
 Dữ liệu biển báo còn khá ít chưa nhiều
Hướng phát triển trong tương lai
 Phát triển thuật toán nhận diện các biển báo phức tạp hơn
 Tạo cơ sở dữ liệu lớn hơn
 Sử dụng thuật toán CNN để phân lớp và xử lý ảnh
Lời kết
Sau khi nghiên cứu và tham khảo , em đã có thể xây dựng một chương trình
nhận diện cơ bản các biển báo giao thông, tuy nhiên vẫn còn nhiều thiếu xót và hạn
chế về thuật toán và lập trình.

26