HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG

CƠ SỞ TP.HCM
KHOA ĐIỆN TỬ 2
______________________

BÀI TẬP LỚN

Môn học: Ngôn ngữ lập trình C++

Đề tài:

Phát hiện các bộ phận khuôn mặt và

chồng mặt nạ

GVGD: HỒ NHỰT MINH

SVTH: Hoàng Minh Tiến – N20DCCN063 ( Nhóm 7 )
Lớp: D23CQDK01-N
 STT HỌ VÀ TÊN SINH VIÊN MSSV CHỮ KÝ

1 Hoàng Minh Tiến N20DCCN063

NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN

TP. HCM, ngày… tháng … năm …

( Ký và ghi rõ họ tên )

Hồ Nhựt Minh
 LỜI CẢM ƠN

Em xin gửi lời cảm ơn chân thành và sâu sắc nhất đến thầy Hồ Nhựt Minh ,
người đã tận tình hướng dẫn, hỗ trợ và chia sẻ những kiến thức quý báu trong
suốt quá trình em thực hiện đề tài môn học này.
Sự chỉ bảo tận tình và những ý kiến đóng góp của thầy đã giúp em không chỉ
hoàn thành bài báo cáo mà còn hiểu rõ hơn về vấn đề nghiên cứu, nâng cao kiến
thức và kỹ năng thực tiễn.
Mặc dù đã nỗ lực hết sức, nhưng do hạn chế về thời gian và kinh nghiệm, bài
báo cáo của em không tránh khỏi những thiếu sót. Em rất mong nhận được
những ý kiến đóng góp thêm từ thầy để em có thể cải thiện và hoàn thiện hơn
trong tương lai.
Em xin chân thành cảm ơn!

Tp. Hồ Chí Minh, ngày 01 tháng 12 năm 2024

Sinh viên thực hiện

Hoàng Minh Tiến

MỤC LỤC
LỜI CẢM ƠN......................................................................................................................... 3
MỤC LỤC...............................................................................................................................4
CHƯƠNG 1: TỔNG QUAN VÀ CƠ SỞ LÝ THUYẾT......................................................6
1. Giới thiệu bài toán.......................................................................................................6
1.1 Tổng quan đề tài nghiên cứu..................................................................................6
1.2 Mục tiêu và phạm vi thực hiện...............................................................................6
1.3 Ý nghĩa và tính ứng dụng thực tế.............................................................................7
1.4 Các thách thức và giới hạn...................................................................................... 7
2. Cơ sở lý thuyết.............................................................................................................. 8
2.1 Các khái niệm cơ bản................................................................................................ 8
2.2 Phân tích các phương pháp........................................................................................9
3. Công nghệ và thư viện sử dụng................................................................................11
3.1 Ngôn ngữ lập trình C++............................................................................................11
3.2 Thư viện chuyên dụng..............................................................................................11
CHƯƠNG 2: THIẾT KẾ VÀ CÀI ĐẶT.............................................................................12
1. Phân tích yêu cầu..........................................................................................................12
1.1 Yêu cầu chức năng...................................................................................................12
1.2 Yêu cầu phi chức năng............................................................................................. 13
2. Thiết kế hệ thống..........................................................................................................13
2.1 Kiến trúc tổng thể...................................................................................................13
2.1.1 Sơ đồ khối hệ thống...............................................................................................13
2.1.2 Các module chính..................................................................................................15
2.1.3 Luồng dữ liệu và xử lý...........................................................................................15
2.2 Thiết kế chi tiết...................................................................................................... 15
2.3 Cài đặt chương trình................................................................................................16
1. Phần đầu chương trình - Khai báo thư viện................................................................16
2. Tạo giao diện trừu tượng IFaceDetector.............................................................17
3. Lớp FaceDetector - Phát hiện mặt và chồng mặt nạ............................................17
4. Lớp FaceMaskApplication - Điều khiển ứng dụng...........................................19
5. Phần mở rộng:........................................................................................................... 20
5.1 Lớp EyeDetector: Phát hiện mắt........................................................................20
5.2 Lớp NoseDetector -Phát hiện mũi....................................................................21
 5.3 Lớp MoustacheDetector – Phát hiện miệng và chồng râu..............................22
5.4 Lớp EarDetector – Phát hiện tai.........................................................................24
6. Main function:........................................................................................................... 25
CHƯƠNG 3. THỰC NGHIỆM VÀ ĐÁNH GIÁ............................................................................27
3.1 Kết quả thực nghiệm................................................................................................... 27
3.2 Hướng phát triển...........................................................................................................31
3.2.1 Các cải tiến có thể thực hiện..................................................................................31
3.2.2 Mở rộng chức năng...............................................................................................31
3.2.1 Tối ưu hiệu năng....................................................................................................32
KẾT LUẬN........................................................................................................................... 32
TÀI LIỆU THAM KHẢO..................................................................................................33
MÃ NGUỒN........................................................................................................................ 33

CHƯƠNG 1: TỔNG QUAN VÀ CƠ SỞ LÝ THUYẾT

1. Giới thiệu bài toán

1.1 Tổng quan đề tài nghiên cứu
Nhận diện các bộ phận của khuôn mặt là một trong những nhiệm vụ phổ biến trong lĩnh vực
thị giác máy tính, với nhiều ứng dụng trong chỉnh sửa hình ảnh, công nghệ thực tế tăng
cường (AR), và phân tích khuôn mặt. Dự án này sử dụng thư viện OpenCV để phát hiện các
bộ phận chính trên khuôn mặt (mắt, mũi, miệng) và chồng lớp mặt nạ (mask overlay) lên các
khu vực tương ứng.
Phương pháp sử dụng trong đề tài tập trung vào việc tận dụng các mô hình đã được huấn
luyện trước, cụ thể là các mô hình Haar Cascade có sẵn trong OpenCV. Đây là kỹ thuật nền
tảng phổ biến, giúp đơn giản hóa quá trình triển khai và đáp ứng yêu cầu xử lý thời gian thực
trong môi trường thực tế.

1.2 Mục tiêu và phạm vi thực hiện

Mục tiêu:

Xây dựng ứng dụng nhận diện khuôn mặt và các bộ phận trên khuôn mặt (facial landmarks)
bằng OpenCV.
Áp dụng kỹ thuật overlay để tạo hiệu ứng hình ảnh hoặc chồng các lớp mặt nạ lên các bộ
phận khuôn mặt như mắt, mũi, hoặc miệng.

 Phạm vi thực hiện:

+ Sử dụng mô hình Haar Cascade của OpenCV để phát hiện khuôn mặt và bộ phận trên
khuôn mặt.
+ Chạy thử nghiệm trên ảnh tĩnh và video thời gian thực từ webcam.
+ Thực hiện chồng lớp mặt nạ theo cách tùy chỉnh, dựa trên các vị trí phát hiện được từ mô
hình Haar Cascade.

1.3 Ý nghĩa và tính ứng dụng thực tế

 Ý nghĩa khoa học:

Giới thiệu các kỹ thuật cơ bản trong phát hiện và theo dõi khuôn mặt bằng OpenCV.

Làm rõ quy trình kết hợp phát hiện khuôn mặt với việc tạo hiệu ứng chồng lớp hình ảnh, đặt
nền tảng cho các ứng dụng phức tạp hơn.

 Ứng dụng thực tế:

Các công cụ chỉnh sửa ảnh và video, đặc biệt trong việc tạo hiệu ứng mặt nạ hoặc làm đẹp.

Cơ sở cho các ứng dụng thực tế tăng cường (AR) như trong các nền tảng mạng xã hội
(Snapchat, Instagram).

1.4 Các thách thức và giới hạn

Thách thức kỹ thuật:

Độ chính xác trong phát hiện các bộ phận trên khuôn mặt phụ thuộc nhiều vào chất lượng dữ
liệu đầu vào (góc quay, độ sáng, vật cản trên khuôn mặt).
Overlay mặt nạ đòi hỏi sự chính xác trong việc định vị các bộ phận khuôn mặt dựa trên
facial landmarks.

Giới hạn công cụ:

Haar Cascade, mặc dù nhanh và nhẹ, nhưng kém chính xác hơn so với các phương pháp hiện
đại dựa trên deep learning.

Độ tin cậy trong môi trường thực tế (điều kiện ánh sáng phức tạp, khuôn mặt bị che khuất) có
thể bị ảnh hưởng.

Giới hạn ứng dụng:

Đề tài này chỉ tập trung vào các kỹ thuật cơ bản và ứng dụng overlay đơn giản, chưa đi sâu
vào các ứng dụng cao cấp như nhận diện cảm xúc hoặc theo dõi chuyển động phức tạp.
Hạn chế trong việc áp dụng vào các ứng dụng bảo mật hoặc nhận diện hành vi phức tạp.

2. Cơ sở lý thuyết
2.1 Các khái niệm cơ bản
2.1.1 Định nghĩa và thuật ngữ chuyên ngành

Face Detection (Phát hiện khuôn mặt): Quá trình nhận diện và định vị khuôn mặt của một
người trong ảnh hoặc video.

Facial Landmarks (Điểm đặc trưng trên khuôn mặt): Các vị trí cụ thể trên khuôn mặt
(như mắt, mũi, miệng) được phát hiện và đánh dấu, giúp xác định cấu trúc và hình dạng của
khuôn mặt.

Mask Overlay (Chồng lớp mặt nạ): Kỹ thuật chèn thêm các hiệu ứng đồ họa (như kính, mặt
nạ, hoặc trang điểm) vào các bộ phận cụ thể trên khuôn mặt dựa vào vị trí facial landmarks.

2.1.2 Các nguyên lý và kỹ thuật liên quan

Nguyên lý phát hiện khuôn mặt:

Haar Cascade:

 Phát hiện dựa trên đặc trưng Haar.

 Các mô hình được huấn luyện sẵn giúp phát hiện nhanh các vùng có đặc điểm giống
khuôn mặt.
 Hiệu quả với dữ liệu đầu vào cơ bản nhưng hạn chế trong các điều kiện phức tạp.

Kỹ thuật Overlay:
 Dựa trên vị trí của facial landmarks để xác định các vùng cần chồng mặt nạ.

 Sử dụng phép biến đổi hình học (như tịnh tiến, xoay, co giãn) để điều chỉnh lớp mặt nạ
phù hợp với kích thước và vị trí bộ phận.

2.1.3 Các thuật toán nền tảng

Haar Cascade Classifier:

Một phương pháp phát hiện khuôn mặt cổ điển dựa trên các đặc trưng Haar. Được huấn luyện
trên các mẫu khuôn mặt và hoạt động bằng cách quét cửa sổ qua từng phần của ảnh.

Ưu điểm: Nhanh, nhẹ, dễ sử dụng.

Nhược điểm: Kém chính xác với điều kiện ánh sáng hoặc góc nhìn không lý tưởng.

OpenCV Image Processing:

OpenCV cung cấp các công cụ cơ bản để xử lý ảnh như phát hiện cạnh, chuyển đổi màu sắc,
và phép biến đổi hình học, hỗ trợ cho cả phát hiện khuôn mặt và chồng lớp hình ảnh.

2.2 Phân tích các phương pháp

2.2.1 So sánh các giải thuật hiện có

Thuật toán Đặc điểm Ứng dụng Hạn chế

Nhanh, dễ triển khai, sử Phát hiện Hiệu suất kém khi

Haar Cascade dụng mô hình dựa trên đặc khuôn mặt cơ ánh sáng hoặc góc
trưng Haar. bản. nhìn thay đổi.

Tìm điểm mắt,

Dlib (Facial Chính xác cao hơn, nhận diện Cần nhiều tài
mũi, miệng,
Landmark) được các landmarks cụ thể. nguyên hơn.
cằm.

Hiệu quả cao nhất cho các Nhận diện

Deep Learning Huấn luyện và
bài toán phức tạp, đặc biệt khuôn mặt
Models (CNNs) triển khai phức tạp.
với tập dữ liệu lớn. nâng cao.
2.2.2 Ưu nhược điểm của từng phương pháp

Haar Cascade:

Ưu điểm:

Nhanh và dễ cài đặt.

Hiệu quả với ảnh đầu vào có chất lượng ổn định.

Nhược điểm:

Độ chính xác thấp trong điều kiện phức tạp.

Khó nhận diện được các landmarks cụ thể trên khuôn mặt.

Dlib's Facial Landmark Detection:

Ưu điểm:

Chính xác và đáng tin cậy hơn trong điều kiện thực tế.

Phát hiện đầy đủ các điểm landmarks trên khuôn mặt.

Nhược điểm:

Tốc độ chậm hơn Haar Cascade trên phần cứng yếu.

Deep Learning (CNNs):

Ưu điểm:

Hiệu quả cao với các bài toán phức tạp, nhận diện chính xác trong điều kiện ánh sáng và góc
nhìn không lý tưởng.

Nhược điểm:

Cần nhiều tài nguyên tính toán.

Phức tạp hơn để triển khai.

2.2.3 Lựa chọn phương pháp phù hợp

 Phương pháp được chọn:

Sử dụng Haar Cascade cho bước phát hiện khuôn mặt và các bộ phận trên khuôn mặt vì:

 Được tích hợp sẵn trong OpenCV, dễ triển khai và sử dụng.

 Đáp ứng yêu cầu về độ nhẹ và tốc độ xử lý cho các bài toán thời gian thực.

3. Công nghệ và thư viện sử dụng

3.1 Ngôn ngữ lập trình C++
3.1.1 Phiên bản C++ sử dụng
Sử dụng C++11 làm chuẩn vì đây là một phiên bản ổn định, hỗ trợ nhiều tính năng mới như
lambda functions, smart pointers và khả năng tương thích cao với các thư viện như OpenCV.
3.1.2 Các tính năng ngôn ngữ cần thiết

 Xử lý chuỗi và container STL: Được sử dụng để quản lý dữ liệu như đường dẫn file
ảnh, video.
 Quản lý bộ nhớ an toàn: Thông qua smart pointers như std::unique_ptr hoặc std::shared_ptr.
 Khả năng liên kết thư viện bên ngoài: Sử dụng các phương pháp liên kết tĩnh hoặc
động để tích hợp OpenCV với dự án.

3.1.3 IDE và công cụ phát triển

 Visual Studio: Được đề xuất trên Windows nhờ tích hợp tốt với các thư viện OpenCV và
khả năng debug mạnh mẽ.
 CMake: Công cụ được sử dụng để cấu hình và xây dựng dự án, giúp quản lý phụ thuộc
và đảm bảo tính nhất quán trên nhiều nền tảng.
 Compiler: Sử dụng GCC (trên Linux) hoặc MSVC (trên Windows) để biên dịch mã
nguồn.

3.2 Thư viện chuyên dụng

OpenCV cho xử lý ảnh:

Phiên bản: OpenCV 4.x.x( 4.10.0), bao gồm các module cần thiết như:

 cv::CascadeClassifier: Để phát hiện khuôn mặt và các bộ phận (mắt, mũi, miệng).
 cv::imshow, cv::waitKey: Hỗ trợ hiển thị ảnh và video với các kết quả đã được xử lý.

OpenCV là thư viện chính của dự án, được sử dụng từ bước phát hiện khuôn mặt đến overlay
mask.
 CHƯƠNG 2: THIẾT KẾ VÀ CÀI ĐẶT

1. Phân tích yêu cầu

1.1 Yêu cầu chức năng
1.1.1 Input/Output của hệ thống

Input:

Ảnh hoặc video chứa khuôn mặt người, có thể từ:

Tệp ảnh (ví dụ: JPG, PNG).
Tệp video (ví dụ: MP4).
Dữ liệu thời gian thực từ camera.

Output:

Ảnh hoặc video có các bộ phận khuôn mặt được phát hiện, bao gồm mắt, mũi, miệng, cằm.
Ảnh hoặc video đã được áp dụng hiệu ứng chồng lớp mặt nạ (mask overlay) chính xác vào
các bộ phận khuôn mặt.

1.1.2 Các tính năng chính

Phát hiện khuôn mặt:

Sử dụng mô hình Haar Cascade trong OpenCV để phát hiện vị trí khuôn mặt trong ảnh hoặc
video.

Nhận diện các bộ phận khuôn mặt (facial parts detection):

Xác định vị trí các bộ phận cụ thể trên khuôn mặt như mắt, mũi, miệng, bằng cách sử dụng
các tệp mô hình Haar Cascade (ví dụ: haarcascade_eye.xml, haarcascade_mcs_nose.xml…).

Overlay mặt nạ (mask overlay):

Sử dụng tọa độ các bộ phận khuôn mặt để chồng các hình ảnh hoặc hiệu ứng đồ họa (như
kính, mặt nạ) lên đúng vị trí khuôn mặt.

1.1.3 Ràng buộc và điều kiện

Yêu cầu đầu vào rõ ràng:

Ảnh hoặc video đầu vào cần có ít nhất một khuôn mặt xuất hiện rõ ràng, không bị che khuất
quá nhiều.

Hạn chế phần cứng:

Hệ thống cần chạy trên máy tính có hỗ trợ webcam (nếu xử lý thời gian thực).

Độ sáng và điều kiện ánh sáng:

Hệ thống có thể bị ảnh hưởng bởi ánh sáng kém hoặc góc quay không thuận lợi.

1.2 Yêu cầu phi chức năng

1.2.1 Hiệu năng và tốc độ xử lý

Hệ thống phải có khả năng xử lý ảnh hoặc video thời gian thực với tốc độ tối thiểu 15 FPS
trên máy tính phổ thông.

Tối ưu hóa hiệu suất bằng cách sử dụng các hàm xử lý ảnh của OpenCV, đảm bảo không gây
chậm trễ lớn khi xử lý video.

1.2.2 Độ chính xác và độ tin cậy

Sử dụng mô hình Haar Cascade để phát hiện khuôn mặt và các bộ phận với độ chính xác cao.

Đảm bảo overlay mask khớp chính xác với các bộ phận của khuôn mặt, ngay cả khi khuôn
mặt di chuyển trong khung hình.

1.2.3 Khả năng mở rộng

- Dễ dàng thêm các loại mặt nạ hoặc hiệu ứng mới, như kính, mũ, hoặc các lớp hóa trang
khác.
- Hỗ trợ nhận diện nhiều khuôn mặt cùng lúc trên cùng một khung hình.
- Hệ thống có thể hoạt động trên nhiều nền tảng (Windows, Linux) và tái sử dụng mã nguồn
khi cần tích hợp thêm tính năng.

2. Thiết kế hệ thống
2.1 Kiến trúc tổng thể
2.1.1 Sơ đồ khối hệ thống

Hệ thống được chia thành các khối chức năng chính, bao gồm:
 Nhập dữ liệu:

Đầu vào từ ảnh (JPG, PNG) hoặc video (MP4, AVI) và nguồn video thời gian thực
(Webcam).

Phát hiện khuôn mặt và bộ phận khuôn mặt:

Sử dụng thuật toán Haar Cascade để phát hiện khuôn mặt và các bộ phận trên
khuôn mặt (mắt, mũi, miệng).

Xác định vị trí facial landmarks:

Định vị và đánh dấu chính xác vị trí các bộ phận bằng tọa độ.

Chồng lớp mặt nạ (mask overlay):

Tạo và áp dụng hiệu ứng chồng lớp hình ảnh hoặc đồ họa lên khuôn mặt.

Xuất dữ liệu

Hiển thị hoặc lưu ảnh/video với hiệu ứng chồng lớp.

2.1.2 Các module chính

Hệ thống được tổ chức thành các module chính như sau:

  Webcam Interface: Dùng cv::VideoCapture để kết nối và đọc dữ liệu từ webcam.
 Detection Modules: Mỗi module được xây dựng dựa trên CascadeClassifier để phát
hiện:
 FaceDetector: Phát hiện khuôn mặt và gắn mặt nạ.
 NoseDetector: Phát hiện mũi và gắn mặt nạ.
 EyeDetector: Phát hiện mắt và gắn kính râm.
 EarDetector: Phát hiện tai và đánh dấu vùng tai.
 MoustacheDetector: Phát hiện miệng và gắn râu.
 Mask Application: Áp dụng mặt nạ lên vùng được phát hiện, sử dụng các kỹ thuật xử
lý ảnh như bitwise_and và add.
 User Interface: Hiển thị kết quả qua cửa sổ hiển thị (cv::imshow).

2.1.3 Luồng dữ liệu và xử lý

1. Dữ liệu đầu vào:

o Webcam cung cấp khung hình (frame) theo thời gian thực.
2. Luồng xử lý:
o Chuyển đổi khung hình sang thang độ xám để tối ưu việc phát hiện.
o Phát hiện khuôn mặt hoặc bộ phận tương ứng qua các mô-đun
CascadeClassifier.
o Xác định ROI (Region of Interest) cho vùng phát hiện.
o Chuyển đổi và áp dụng mặt nạ (mask) trên ROI.
3. Dữ liệu đầu ra:
o Khung hình đã qua xử lý được hiển thị trên giao diện.

2.2 Thiết kế chi tiết

2.2.1 Cấu trúc dữ liệu

 Mat: Dữ liệu hình ảnh từ OpenCV, được sử dụng trong mọi khâu xử lý (khung hình,
mặt nạ, ROI).
 CascadeClassifier: Dùng để lưu trữ và thực thi các mô hình phát hiện đặc trưng Haar.
 Rect: Xác định vùng phát hiện (ROI) trong khung hình.
 vector<Rect>: Lưu trữ danh sách các vùng phát hiện.

2.2.2 Thuật toán xử lý

1. Phát hiện khuôn mặt và bộ phận:

o Dùng CascadeClassifier để phát hiện vùng.
o Tăng cường hiệu quả bằng cách thay đổi tỷ lệ hình ảnh (scaling factor) và
histogram equalization.
2. Xử lý mặt nạ:
o Chuyển đổi mặt nạ: Chuyển đổi sang thang xám, tạo các mask nhị phân
(binary mask) để kết hợp hình ảnh.
 o Áp dụng mặt nạ:
 Sử dụng bitwise_and để kết hợp mask lên ROI.
 Sử dụng add để hợp nhất vùng xử lý với khung hình.
3. Hiển thị:
o Sau khi xử lý xong, kết quả được hiển thị bằng cv::imshow.

2.2.3 Giao diện người dùng

 Người dùng có thể chạy ứng dụng thông qua dòng lệnh:

./application <mode> <cascade_file_1> <cascade_file_2|mask_image>

Trong đó:

o mode: Lựa chọn kiểu phát hiện (face, nose, eye, ear, moustache).
o cascade_file_1: Đường dẫn file cascade đầu tiên (ví dụ: face cascade).
o cascade_file_2|mask_image: Đường dẫn file cascade thứ hai (nếu có) hoặc
hình ảnh mặt nạ.

 Giao diện hiển thị thông qua cửa sổ OpenCV (Frame) với hình ảnh xử lý theo thời
gian thực. Người dùng có thể nhấn phím Esc để thoát.

2.3 Cài đặt chương trình

1. Phần đầu chương trình - Khai báo thư viện

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/objdetect/objdetect.hpp>
#include <iostream>
#include <stdexcept>

Thư viện OpenCV:

 highgui/highgui.hpp: Dùng để hiển thị và xử lý cửa sổ đồ họa (ví dụ: hiển thị
webcam).
 imgproc/imgproc.hpp: Hỗ trợ các phép toán xử lý ảnh như chuyển đổi màu, resize ảnh,
tạo mặt nạ...
 objdetect/objdetect.hpp: Dùng để phát hiện đối tượng (như mặt, mũi, mắt) bằng cách
dùng các mô hình Haar Cascade.

Thư viện chuẩn C++:

 iostream: Xử lý nhập xuất console (như in lỗi, thông báo).

 stdexcept: Xử lý ngoại lệ (exception).

2. Tạo giao diện trừu tượng IFaceDetector

class IFaceDetector {
public:
virtual void detectAndApplyMask(Mat& frame) = 0;
virtual ~IFaceDetector() = default;
};

 IFaceDetector:
o Là lớp giao diện (interface) cho các bộ phát hiện như mặt, mũi, mắt, tai.
o Mỗi lớp cụ thể sẽ cần cài đặt phương thức detectAndApplyMask để thực hiện
chức năng tương ứng.

 Lợi ích:
o Cho phép các thành phần trong chương trình (như lớp ứng dụng) sử dụng các
bộ phát hiện khác nhau mà không cần biết chi tiết bên trong.

3. Lớp FaceDetector - Phát hiện mặt và chồng mặt nạ

class FaceDetector : public IFaceDetector {

private:
CascadeClassifier faceCascade;
Mat faceMask;
float scalingFactor;

void loadCascade(const string& cascadePath) {

if (!faceCascade.load(cascadePath)) {
throw runtime_error("Error loading cascade file.");
}
}

void loadFaceMask(const string& maskPath) {

faceMask = imread(maskPath);
if (!faceMask.data) {
throw runtime_error("Error loading mask image.");
}
}

public:
FaceDetector(const string& cascadePath, const string& maskPath, float scale = 0.75)
: scalingFactor(scale) {
loadCascade(cascadePath);
loadFaceMask(maskPath);
}
 void detectAndApplyMask(Mat& frame) override {
Mat frameGray, frameROI, faceMaskSmall;
Mat grayMaskSmall, grayMaskSmallThresh, grayMaskSmallThreshInv;
Mat maskedFace, maskedFrame;

// Thay đổi kích thước khung

resize(frame, frame, Size(), scalingFactor, scalingFactor, INTER_AREA);

// Convert frame to grayscale

cvtColor(frame, frameGray, COLOR_BGR2GRAY);
equalizeHist(frameGray, frameGray);

// Detect faces
vector<Rect> faces;
faceCascade.detectMultiScale(frameGray, faces, 1.1, 2, 0 | 2, Size(30, 30));

for (const auto& face : faces) {

int x = face.x - int(0.1 * face.width);
int y = face.y - int(0.0 * face.height);
int w = int(1.1 * face.width);
int h = int(1.3 * face.height);

if (x > 0 && y > 0 && x + w < frame.cols && y + h < frame.rows) {

frameROI = frame(Rect(x, y, w, h));
resize(faceMask, faceMaskSmall, Size(w, h));
cvtColor(faceMaskSmall, grayMaskSmall, COLOR_BGR2GRAY);

threshold(grayMaskSmall, grayMaskSmallThresh, 230, 255, THRESH_BINARY_INV);

bitwise_not(grayMaskSmallThresh, grayMaskSmallThreshInv);
bitwise_and(faceMaskSmall, faceMaskSmall, maskedFace, grayMaskSmallThresh);
bitwise_and(frameROI, frameROI, maskedFrame, grayMaskSmallThreshInv);

add(maskedFace, maskedFrame, frame(Rect(x, y, w, h)));

}
}
}
};

Giải thích:

1. Thuộc tính:
o faceCascade: Bộ phân loại Haar Cascade dùng để phát hiện mặt.
o faceMask: Ảnh mặt nạ sẽ chồng lên khuôn mặt.
o scalingFactor: Tỷ lệ thu nhỏ ảnh, giúp tăng tốc độ xử lý.

2. Hàm dựng:
o Gọi loadCascade để tải mô hình Haar Cascade từ tệp.
o Gọi loadFaceMask để tải ảnh mặt nạ.

3. Hàm phát hiện và chồng mặt nạ:

o Resize ảnh đầu vào: Ảnh được thu nhỏ với scalingFactor.
o Chuyển sang ảnh xám: Giúp bộ phát hiện hoạt động chính xác hơn.
o Phát hiện khuôn mặt: Sử dụng detectMultiScale từ OpenCV.
o Chồng mặt nạ:
 Xác định ROI (Region of Interest) của khuôn mặt.
  Resize ảnh mặt nạ cho khớp ROI.
 Áp dụng các phép toán mặt nạ để kết hợp ảnh mặt nạ và ảnh gốc

4. Lớp FaceMaskApplication - Điều khiển ứng dụng

class FaceMaskApplication {
private:
unique_ptr<IFaceDetector> detector;
VideoCapture cap;

public:
FaceMaskApplication(unique_ptr<IFaceDetector> detector) : detector(move(detector)) {
if (!cap.open(0)) {
throw runtime_error("Error opening webcam.");
}
namedWindow("Frame");
}

void run() {
Mat frame;
while (true) {
cap >> frame;
if (frame.empty()) {
cerr << "Error capturing frame. Exiting!" << endl;
break;
}

try {
detector->detectAndApplyMask(frame);
}
catch (const exception& e) {
cerr << e.what() << endl;
break;
}

imshow("Frame", frame);
if (waitKey(30) == 27) { // Exit on 'Esc'
break;
}
}
cap.release();
destroyAllWindows();
}
};

Giải thích:

1. Thuộc tính:
o detector: Bộ phát hiện (mặt, mắt, mũi...) được truyền từ lớp cha
IFaceDetector.
o cap: Đối tượng quay video từ webcam.

2. Hàm dựng:
o Mở webcam (cap.open(0)).
o Khởi tạo cửa sổ hiển thị (namedWindow).
3. Vòng lặp chính (run):
o Nhận khung hình: Đọc từng khung ảnh từ webcam.
o Áp dụng bộ phát hiện: Gọi detectAndApplyMask trên từng khung.
o Hiển thị: Hiển thị khung hình đã xử lý.
o Thoát chương trình: Nhấn phím Esc để thoát.

5. Phần mở rộng:

Kế thừa từ giao diện IFaceDetector, các lớp mở rộng như EyeDetector, NoseDetector, và
MoustacheDetector được xây dựng để phát hiện và chồng các mặt nạ đặc thù lên các bộ
phận như mắt, mũi, miệng.

Mục tiêu chính:

 Xây dựng lớp phát hiện bộ phận cụ thể, sử dụng các mô hình Haar Cascade tương ứng.
 Chồng mặt nạ lên vùng phát hiện với các điều chỉnh cần thiết.

5.1 Lớp EyeDetector: Phát hiện mắt

Lớp EyeDetector sử dụng mô hình Haar Cascade để phát hiện mắt và chồng ảnh mặt nạ (ví
dụ: kính mắt). Lớp này kế thừa từ IFaceDetector.

class EyeDetector : public IFaceDetector {

private:
CascadeClassifier eyeCascade; // Bộ phát hiện mắt
Mat eyeMask; // Ảnh mặt nạ dành cho mắt
float scalingFactor; // Hệ số thu nhỏ khung hình

void loadCascade(const string& cascadePath) {

if (!eyeCascade.load(cascadePath)) {
throw runtime_error("Error loading eye cascade file.");
}
}

void loadEyeMask(const string& maskPath) {

eyeMask = imread(maskPath);
if (!eyeMask.data) {
throw runtime_error("Error loading eye mask image.");
}
}

public:
EyeDetector(const string& cascadePath, const string& maskPath, float scale = 0.75)
: scalingFactor(scale) {
loadCascade(cascadePath);
loadEyeMask(maskPath);
 }

void detectAndApplyMask(Mat& frame) override {

Mat frameGray, eyeMaskSmall, frameROI, grayMaskSmall, grayMaskSmallThresh,
grayMaskSmallThreshInv;
Mat maskedEye, maskedFrame;

resize(frame, frame, Size(), scalingFactor, scalingFactor, INTER_AREA);

cvtColor(frame, frameGray, COLOR_BGR2GRAY);
equalizeHist(frameGray, frameGray);

vector<Rect> eyes;
eyeCascade.detectMultiScale(frameGray, eyes, 1.1, 2, 0 | 2, Size(30, 30));

for (const auto& eye : eyes) {

int x = eye.x;
int y = eye.y;
int w = eye.width;
int h = eye.height;

if (x > 0 && y > 0 && x + w < frame.cols && y + h < frame.rows) {

frameROI = frame(Rect(x, y, w, h));
resize(eyeMask, eyeMaskSmall, Size(w, h));
cvtColor(eyeMaskSmall, grayMaskSmall, COLOR_BGR2GRAY);

threshold(grayMaskSmall, grayMaskSmallThresh, 230, 255, THRESH_BINARY_INV);

bitwise_not(grayMaskSmallThresh, grayMaskSmallThreshInv);
bitwise_and(eyeMaskSmall, eyeMaskSmall, maskedEye, grayMaskSmallThresh);
bitwise_and(frameROI, frameROI, maskedFrame, grayMaskSmallThreshInv);

add(maskedEye, maskedFrame, frame(Rect(x, y, w, h)));

}
}
}
};

5.2 Lớp NoseDetector -Phát hiện mũi

Nhiệm vụ: Phát hiện mũi và chồng mặt nạ (ví dụ: mũi hề).

Cách hoạt động:

 Sử dụng mô hình Haar Cascade phát hiện mũi (haarcascade_mcs_nose.xml).

 Chồng mặt nạ vào vị trí trung tâm của vùng mũi.

class NoseDetector : public IFaceDetector {

private:
CascadeClassifier noseCascade;
Mat noseMask;

public:
NoseDetector(const string& cascadePath, const string& maskPath) {
if (!noseCascade.load(cascadePath)) {
 throw runtime_error("Error loading nose cascade file.");
}
noseMask = imread(maskPath);
if (!noseMask.data) {
throw runtime_error("Error loading nose mask image.");
}
}

void detectAndApplyMask(Mat& frame) override {

Mat frameGray;
cvtColor(frame, frameGray, COLOR_BGR2GRAY);
equalizeHist(frameGray, frameGray);

vector<Rect> noses;
noseCascade.detectMultiScale(frameGray, noses, 1.1, 3, 0 | 2, Size(30, 30));

for (const auto& nose : noses) {

Mat roi = frame(nose);
Mat resizedMask;
resize(noseMask, resizedMask, Size(nose.width, nose.height));
resizedMask.copyTo(roi);
}
}
};

5.3 Lớp MoustacheDetector – Phát hiện miệng và chồng râu

Cách hoạt động:

 Sử dụng Haar Cascade phát hiện miệng.

 Vị trí mặt nạ (râu) được đặt dưới mũi, phù hợp với kích thước vùng miệng.

class MoustacheDetector : public IFaceDetector {

private:
CascadeClassifier faceCascade;
CascadeClassifier mouthCascade;
Mat moustacheMask;
float scalingFactor;

void loadCascade(const string& cascadePath, CascadeClassifier& cascade) {

if (!cascade.load(cascadePath)) {
throw runtime_error("Error loading cascade file: " + cascadePath);
}
}

void loadMask(const string& maskPath, Mat& mask) {

mask = imread(maskPath);
if (!mask.data) {
throw runtime_error("Error loading moustache mask image: " + maskPath);
}
}

public:
 MoustacheDetector(const string& faceCascadePath, const string& mouthCascadePath, const
string& maskPath, float scale = 0.75)
: scalingFactor(scale) {
loadCascade(faceCascadePath, faceCascade);
loadCascade(mouthCascadePath, mouthCascade);
loadMask(maskPath, moustacheMask);
}

void detectAndApplyMask(Mat& frame) override {

Mat frameGray;
vector<Rect> faces;

// Resize the frame

resize(frame, frame, Size(), scalingFactor, scalingFactor, INTER_AREA);

// Convert to grayscale
cvtColor(frame, frameGray, COLOR_BGR2GRAY);

// Detect faces
faceCascade.detectMultiScale(frameGray, faces, 1.1, 2, 0 | CASCADE_SCALE_IMAGE,
Size(30, 30));

// Process each detected face

for (const auto& face : faces) {
Mat faceROI = frameGray(face);
vector<Rect> mouths;

// Detect mouths within the face ROI

mouthCascade.detectMultiScale(faceROI, mouths, 1.1, 5, 0 | CASCADE_SCALE_IMAGE,
Size(30, 30));

for (const auto& mouth : mouths) {

int w = 1.8 * mouth.width;
int h = mouth.height;
int x = face.x + mouth.x - 0.2 * w;
int y = face.y + mouth.y + 0.65 * h;

// Region of Interest (ROI) for moustache placement

Mat frameROI = frame(Rect(x, y, w, h));

// Resize the moustache mask to fit the ROI

Mat moustacheMaskResized;
resize(moustacheMask, moustacheMaskResized, Size(w, h));

// Create grayscale mask and threshold images

Mat grayMask, grayMaskThresh, grayMaskThreshInv;
cvtColor(moustacheMaskResized, grayMask, COLOR_BGR2GRAY);
threshold(grayMask, grayMaskThresh, 245, 255, THRESH_BINARY_INV);
bitwise_not(grayMaskThresh, grayMaskThreshInv);

// Masked moustache and frame

Mat maskedMoustache, maskedFrame;
bitwise_and(moustacheMaskResized, moustacheMaskResized, maskedMoustache,
grayMaskThresh);
bitwise_and(frameROI, frameROI, maskedFrame, grayMaskThreshInv);

// Combine the masked images

add(maskedMoustache, maskedFrame, frame(Rect(x, y, w, h)));
}
}
}
};
5.4 Lớp EarDetector – Phát hiện tai

 Sử dụng mô hình Haar Cascade phát hiện tai (có thể sử dụng mô hình Haar Cascade như
haarcascade_mcs_rightear.xml và haarcascade_mcs_leftear.xml cho tai bên phải và
bên trái).

 Chồng mặt nạ lên khu vực tai được phát hiện.

class EarDetector : public IFaceDetector {

private:
CascadeClassifier leftEarCascade; // Phát hiện tai trái
CascadeClassifier rightEarCascade; // Phát hiện tai phải
Mat earMask; // Mặt nạ tai

public:
EarDetector(const string& leftEarCascadePath, const string& rightEarCascadePath, const
string& maskPath) {
if (!leftEarCascade.load(leftEarCascadePath)) {
throw runtime_error("Error loading left ear cascade file.");
}
if (!rightEarCascade.load(rightEarCascadePath)) {
throw runtime_error("Error loading right ear cascade file.");
}
earMask = imread(maskPath);
if (!earMask.data) {
throw runtime_error("Error loading ear mask image.");
}
}

void detectAndApplyMask(Mat& frame) override {

Mat frameGray;
cvtColor(frame, frameGray, COLOR_BGR2GRAY);
equalizeHist(frameGray, frameGray);

// Phát hiện tai trái

vector<Rect> leftEars;
leftEarCascade.detectMultiScale(frameGray, leftEars, 1.1, 3, 0 | 2, Size(30, 30));

for (const auto& ear : leftEars) {

int x = ear.x;
int y = ear.y;
int w = ear.width;
int h = ear.height;

if (x > 0 && y > 0 && x + w < frame.cols && y + h < frame.rows) {

Mat frameROI = frame(Rect(x, y, w, h));
Mat resizedMask;
resize(earMask, resizedMask, Size(w, h));
resizedMask.copyTo(frameROI);
}
}

// Phát hiện tai phải

vector<Rect> rightEars;
rightEarCascade.detectMultiScale(frameGray, rightEars, 1.1, 3, 0 | 2, Size(30, 30));

for (const auto& ear : rightEars) {

int x = ear.x;
int y = ear.y;
int w = ear.width;
int h = ear.height;
 if (x > 0 && y > 0 && x + w < frame.cols && y + h < frame.rows) {
Mat frameROI = frame(Rect(x, y, w, h));
Mat resizedMask;
resize(earMask, resizedMask, Size(w, h));
resizedMask.copyTo(frameROI);
}
}
}
};

6. Main function:

Hàm main là điểm khởi chạy chương trình, cho phép:

 Chọn chế độ hoạt động (phát hiện khuôn mặt, mắt, mũi, râu).
 Khởi tạo lớp phát hiện tương ứng với chế độ.
 Chạy ứng dụng phát hiện và chồng mặt nạ.

// Main function

int main(int argc, char* argv[]) {

if (argc < 4) {
cerr << "Usage: " << argv[0] << " <mode> <cascade_file_1> <cascade_file_2|
mask_image>" << endl;
cerr << "Modes: face | nose | eye | ear | moustache" << endl;
return -1;
}

string mode = argv[1];

try {
unique_ptr<IFaceDetector> detector;
if (mode == "face") {
detector = make_unique<FaceDetector>(argv[2], argv[3]);
}
else if (mode == "nose") {
if (argc < 5) {
cerr << "Usage for nose mode: " << argv[0] << " nose <face_cascade>
<nose_cascade> <mask_image>" << endl;
return -1;
}
detector = make_unique<NoseDetector>(argv[2], argv[3], argv[4]);
}
else if (mode == "eye") {
if (argc < 5) {
cerr << "Usage for eye mode: " << argv[0] << " eye <face_cascade>
<eye_cascade> <mask_image>" << endl;
return -1;
}
detector = make_unique<EyeDetector>(argv[2], argv[3], argv[4]);
}
else if (mode == "ear") {
detector = make_unique<EarDetector>(argv[2], argv[3]);
}
else if (mode == "moustache") {
 if (argc < 5) {
cerr << "Usage for moustache mode: " << argv[0] << " moustache
<face_cascade> <mouth_cascade> <mask_image>" << endl;
return -1;
}
detector = make_unique<MoustacheDetector>(argv[2], argv[3], argv[4]);
}
else {
cerr << "Invalid mode: " << mode << endl;
return -1;
}

FaceMaskApplication app(move(detector));
app.run();
}
catch (const exception& e) {
cerr << "Error: " << e.what() << endl;
return -1;
}

return 0;
}

 Quy trình thực hiện trong hàm main

Xử lý đầu vào từ dòng lệnh:

1. Người dùng sẽ chọn chế độ phát hiện qua tham số dòng lệnh, chẳng hạn như "face",
"eye", "nose", "moustache", hoặc "ear".
2. Người dùng cũng cần cung cấp đường dẫn đến file cascade và mặt nạ (mask) cho chế độ
đó.

Khởi tạo lớp phát hiện:

Dựa vào chế độ (mode) người dùng chọn, hàm main sẽ khởi tạo một đối tượng của lớp tương
ứng (FaceDetector, EyeDetector, NoseDetector, MoustacheDetector, hoặc
EarDetector).

Chạy chương trình phát hiện:

Sau khi khởi tạo lớp phát hiện, đối tượng đó sẽ được truyền vào một lớp
FaceMaskApplication, và phương thức run sẽ được gọi để thực hiện phát hiện và chồng mặt
nạ lên các khu vực cần thiết trên ảnh hoặc video.

CHƯƠNG 3. THỰC NGHIỆM VÀ ĐÁNH GIÁ

3.1 Kết quả thực nghiệm

Kết quả khi thử nghiệm với các bộ phận khác nhau trên khuôn mặt:

1. Toàn bộ khuôn mặt

Chạy lệnh

 Mô tả: Phát hiện khuôn mặt và phủ lớp mặt nạ lên toàn bộ khuôn mặt.

 Kết quả: Hệ thống có thể phát hiện và phủ lớp mặt nạ chính xác trên các khuôn mặt trong
các ảnh có điều kiện ánh sáng khác nhau.

2. Mũi

Chạy lệnh
 Mô tả: Phát hiện mũi và phủ lớp mask lên mũi.
 Kết quả: Lớp mặt nạ được phủ lên mũi chính xác, ngay cả trong các điều kiện không gian
có ánh sáng yếu hoặc góc nhìn khác biệt.

3. Tai
Chạy lệnh
 Mô tả: Phát hiện tai và phủ lớp mask lên tai.
 Kết quả: Hệ thống phát hiện tai trong ảnh có độ chính xác cao, mặc dù trong một số
trường hợp với góc nhìn nghiêng hoặc ảnh có độ sáng thấp, việc phát hiện có thể bị hạn chế.
4. Miệng
Chạy lệnh

 Mô tả: Phát hiện miệng và phủ lớp mask lên miệng.

 Kết quả: Hệ thống phát hiện miệng và phủ lớp mask không chính xác. Các thử nghiệm
với miệng cho thấy sự phát hiện không ổn định trong điều kiện khác nhau của môi trường ánh
sáng và góc nhìn.
5. Mắt
 Mô tả: Phát hiện mắt và phủ lớp mask lên mắt.
 Kết quả: Mắt được phát hiện và lớp mask phủ chính xác, ngay cả khi có sự thay đổi trong
độ sáng và góc nhìn.

3.2 Hướng phát triển

3.2.1 Các cải tiến có thể thực hiện

 Cải thiện độ chính xác của việc phát hiện các bộ phận khuôn mặt:

 Sử dụng Deep Learning: Thay vì chỉ sử dụng các cascade classifier, có thể cải thiện
độ chính xác và khả năng nhận diện với các mô hình deep learning như YOLO (You
Only Look Once) hoặc MTCNN (Multi-task Cascaded Convolutional Networks) cho
việc phát hiện khuôn mặt và các bộ phận như mắt, mũi, và miệng.
 Huấn luyện lại các cascade classifier: Thử huấn luyện lại các cascade classifier với
bộ dữ liệu đa dạng hơn để hệ thống nhận diện tốt hơn trong các điều kiện thực tế, đặc
biệt là trong các ảnh có chất lượng thấp hoặc với các góc nhìn khác nhau.

 Phát triển một hệ thống tự động phát hiện khuôn mặt trong video:

 Thay vì chỉ xử lý một hình ảnh tĩnh, hệ thống có thể được mở rộng để phát hiện và
phủ lớp mask trong các video trực tiếp, tạo nên một ứng dụng thú vị và thực tiễn hơn.
 Phát triển tính năng phát hiện và áp dụng mask theo thời gian thực (real-time).

 Xử lý các tình huống phức tạp hơn (nhiều khuôn mặt):

Mở rộng khả năng phát hiện và xử lý nhiều khuôn mặt trong một hình ảnh, giúp hệ thống có
thể hoạt động trong các môi trường với nhiều người (ví dụ: các sự kiện, hội nghị video, v.v.).
3.2.2 Mở rộng chức năng

 Thêm tính năng nhận diện các bộ phận khuôn mặt khác:

Hệ thống có thể được mở rộng để nhận diện và phủ lớp mask lên các bộ phận khác như
miệng, lông mày, hoặc thậm chí là các đặc điểm nhận diện đặc biệt (ví dụ: nhận diện cảm xúc
khuôn mặt).

 Hỗ trợ nhiều loại mask khác nhau:

Mở rộng hệ thống để hỗ trợ nhiều loại mask khác nhau cho từng bộ phận khuôn mặt, chẳng
hạn như mặt nạ Halloween, mặt nạ động vật, hay các loại trang phục khác.

 Thêm khả năng tùy chỉnh kích thước và vị trí của mask:

Cho phép người dùng tùy chỉnh kích thước, vị trí và thậm chí là hiệu ứng chuyển động của
mask trên khuôn mặt, giúp hệ thống linh hoạt hơn và dễ sử dụng.

3.2.1 Tối ưu hiệu năng

 Tối ưu hóa tốc độ xử lý:

 Để hệ thống hoạt động hiệu quả hơn, đặc biệt trong môi trường thời gian thực (real-
time), có thể tối ưu hóa mã nguồn, sử dụng các thư viện hoặc thuật toán mạnh mẽ hơn
cho việc xử lý ảnh như OpenCV DNN module hoặc TensorFlow Lite cho các mô hình
học sâu.
 Giảm thời gian xử lý cho từng frame trong video bằng cách áp dụng các kỹ thuật tối
ưu hóa như multi-threading hoặc GPU acceleration.

 Quản lý bộ nhớ hiệu quả hơn:

Khi làm việc với các ảnh/video có độ phân giải cao, việc tối ưu hóa bộ nhớ và các phép toán
xử lý ảnh là rất quan trọng. Có thể sử dụng các thư viện như cv::UMat trong OpenCV để xử lý
ảnh với hiệu suất cao hơn và tiết kiệm bộ nhớ.

 Sử dụng các công cụ nén ảnh:

Khi làm việc với video hoặc hình ảnh có kích thước lớn, sử dụng các kỹ thuật nén ảnh thông
minh như JPEG 2000 hoặc WebP để giảm dung lượng và tăng tốc độ xử lý mà không làm
giảm chất lượng ảnh quá nhiều.

KẾT LUẬN

Trong đề tài "Phát hiện các bộ phận khuôn mặt và phủ mặt nạ dựa trên OpenCV", em đã xây
dựng một hệ thống có khả năng phát hiện và nhận diện các bộ phận khuôn mặt như mắt, mũi,
tai, miệng, và toàn bộ khuôn mặt, sau đó phủ lớp mặt nạ tương ứng lên các bộ phận này. Hệ
thống được triển khai với các công cụ và thư viện hiện đại như OpenCV và ứng dụng các kỹ
thuật xử lý ảnh tiên tiến như cascade classifier. Qua các thử nghiệm, kết quả cho thấy hệ
thống hoạt động chính xác và ổn định trong nhiều điều kiện môi trường khác nhau, từ ánh
sáng mạnh, ánh sáng yếu đến các góc nhìn phức tạp.

Bên cạnh những thành công đạt được, hệ thống vẫn tồn tại một số hạn chế, như hiệu suất
giảm khi xử lý các ảnh hoặc video có độ phân giải cao hoặc trong điều kiện ánh sáng cực kỳ
yếu. Điều này mở ra các hướng phát triển tiềm năng trong tương lai, bao gồm việc ứng dụng
các mô hình học sâu để tăng độ chính xác, tối ưu hóa hiệu năng để hỗ trợ thời gian thực, và
mở rộng khả năng xử lý trên video trực tiếp hoặc nhận diện nhiều khuôn mặt cùng lúc.

Nhìn chung, đề tài này không chỉ đáp ứng được các mục tiêu đặt ra mà còn cung cấp một nền
tảng vững chắc để phát triển các ứng dụng thực tiễn khác, như tạo hiệu ứng trên khuôn mặt,
hỗ trợ công nghệ thực tế tăng cường (AR), hoặc các hệ thống giám sát thông minh. Hệ thống
này là một ví dụ điển hình cho việc ứng dụng các kỹ thuật xử lý ảnh và trí tuệ nhân tạo trong
việc giải quyết các bài toán liên quan đến nhận diện khuôn mặt và cá nhân hóa hình ảnh.

--------------------------------------------------------
TÀI LIỆU THAM KHẢO

[1] Millan Escriva, D., Mendonca, V. G., & Joshi, P. (2018). Learn OpenCV 4 by Building
Projects - Second Edition. Packt Publishing.

[2] Github Learn-OpenCV-4-By-Building-Projects-Second-Edition.

(https://github.com/PacktPublishing/Learn-OpenCV-4-By-Building-Projects-Second-
Edition/tree/master/Chapter_07)

MÃ NGUỒN:

Link github: https://github.com/gasieusao98/Detecting-Face-Parts-and-Overlaying-Masks1

Link Notion: https://frost-cell-cdc.notion.site/Detecting-Face-Parts-and-Overlaying-Mask-
15547e2c5784805fa81bfdf6a4a42928?pvs=4

Link youtube: https://youtu.be/FwcQ5jmvlBk?si=TEw_gQxIWfAzTgMl