Python

# Sample code nghe nhạc cần há miệng, mở mắt, há càng to âm thanh càng to, mắt nhắm nhạc tắt.
# Để cài các thư viện mọi người dùng terminal dạng `pip install comtypes`, `pip install pycaw` nha. Sau install là tên thư viện.
# Trên Windows mọi người build sẽ cần bổ sung thư viện python sẽ yêu cầu trên thông báo lỗi nhé!

import cv2
import sys
import mediapipe as mp
import numpy as np
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QVBoxLayout, QWidget
from PyQt5.QtCore import QTimer, QThread, pyqtSignal, pyqtSlot, Qt
from PyQt5.QtGui import QImage, QPixmap
import os

def set_volume_mac(volume):
    volume = max(0, min(100, volume))  # Đảm bảo âm lượng trong phạm vi hợp lệ
    os.system(f"osascript -e 'set volume output volume {volume}'")

def draw_volume_bar(image, volume):
    h, w, _ = image.shape
    bar_height = 300
    bar_width = 20
    bar_x = w - bar_width - 20
    bar_y = (h - bar_height) // 2

cv2.rectangle(image, (bar_x, bar_y), (bar_x + bar_width, bar_y + bar_height), (255, 255, 255), 2)
    loading_height = int(bar_height * (volume / 100))
    loading_y = bar_y + (bar_height - loading_height)
    cv2.rectangle(image, (bar_x, loading_y), (bar_x + bar_width, bar_y + bar_height), (0, 255, 0), -1)
    cv2.putText(image, f'{int(volume)}%', (bar_x - 70, bar_y + bar_height + 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

class VideoThread(QThread):
    change_pixmap_signal = pyqtSignal(np.ndarray)
    finished_signal = pyqtSignal()

def __init__(self):
        super().__init__()
        self._run_flag = False
        self.cap = None
        self.mp_face_mesh = mp.solutions.face_mesh
        self.face_mesh = self.mp_face_mesh.FaceMesh(min_detection_confidence=0.7, min_tracking_confidence=0.5)

def run(self):
        self.cap = cv2.VideoCapture(0)
        self._run_flag = True
        while self._run_flag:
            ret, frame = self.cap.read()
            if ret:
                image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                image.flags.writeable = False
                results = self.face_mesh.process(image)
                image.flags.writeable = True
                image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)

if results.multi_face_landmarks:
                    face_landmarks = results.multi_face_landmarks[0]
                    h, w, _ = image.shape
                    
                    # Lấy tọa độ các điểm cần thiết
                    top_lip = face_landmarks.landmark[13]  # Trung điểm môi trên
                    bottom_lip = face_landmarks.landmark[14]  # Trung điểm môi dưới
                    left_corner = face_landmarks.landmark[61]
                    right_corner = face_landmarks.landmark[291]
                    left_eye_upper = face_landmarks.landmark[159]
                    left_eye_lower = face_landmarks.landmark[145]
                    right_eye_upper = face_landmarks.landmark[386]
                    right_eye_lower = face_landmarks.landmark[374]
                    left_eye_inner = face_landmarks.landmark[133]
                    left_eye_outer = face_landmarks.landmark[33]
                    right_eye_inner = face_landmarks.landmark[362]
                    right_eye_outer = face_landmarks.landmark[263]

# Đổi nhãn mắt trái và mắt phải để phù hợp với hướng thực
                    # Mắt trái (thực): sử dụng điểm của mắt phải
                    # Mắt phải (thực): sử dụng điểm của mắt trái
                    left_eye_upper_coords = (int(right_eye_upper.x * w), int(right_eye_upper.y * h))
                    left_eye_lower_coords = (int(right_eye_lower.x * w), int(right_eye_lower.y * h))
                    left_eye_inner_coords = (int(right_eye_inner.x * w), int(right_eye_inner.y * h))
                    left_eye_outer_coords = (int(right_eye_outer.x * w), int(right_eye_outer.y * h))

right_eye_upper_coords = (int(left_eye_upper.x * w), int(left_eye_upper.y * h))
                    right_eye_lower_coords = (int(left_eye_lower.x * w), int(left_eye_lower.y * h))
                    right_eye_inner_coords = (int(left_eye_inner.x * w), int(left_eye_inner.y * h))
                    right_eye_outer_coords = (int(left_eye_outer.x * w), int(left_eye_outer.y * h))

# Tọa độ môi (giữ nguyên)
                    top_lip_coords = (int(top_lip.x * w), int((top_lip.y - 0.02) * h))
                    bottom_lip_coords = (int(bottom_lip.x * w), int((bottom_lip.y + 0.03) * h))
                    left_corner_coords = (int(left_corner.x * w), int(left_corner.y * h))
                    right_corner_coords = (int(right_corner.x * w), int(right_corner.y * h))

# Vẽ phần miệng (giữ nguyên)
                    cv2.circle(image, top_lip_coords, 5, (0, 0, 255), -1)
                    cv2.circle(image, bottom_lip_coords, 5, (0, 0, 255), -1)
                    cv2.circle(image, left_corner_coords, 5, (0, 0, 255), -1)
                    cv2.circle(image, right_corner_coords, 5, (0, 0, 255), -1)

cv2.line(image, top_lip_coords, bottom_lip_coords, (0, 255, 0), 2)
                    cv2.line(image, left_corner_coords, top_lip_coords, (255, 0, 0), 2)
                    cv2.line(image, right_corner_coords, top_lip_coords, (255, 0, 0), 2)
                    cv2.line(image, left_corner_coords, bottom_lip_coords, (255, 0, 0), 2)
                    cv2.line(image, right_corner_coords, bottom_lip_coords, (255, 0, 0), 2)

# Vẽ đa giác đầy đủ cho mắt trái
                    cv2.line(image, left_eye_upper_coords, left_eye_lower_coords, (0, 255, 0), 2)
                    cv2.line(image, left_eye_inner_coords, left_eye_upper_coords, (0, 255, 255), 2)
                    cv2.line(image, left_eye_inner_coords, left_eye_lower_coords, (0, 255, 255), 2)
                    cv2.line(image, left_eye_outer_coords, left_eye_upper_coords, (0, 255, 255), 2)
                    cv2.line(image, left_eye_outer_coords, left_eye_lower_coords, (0, 255, 255), 2)

# Vẽ đa giác đầy đủ cho mắt phải
                    cv2.line(image, right_eye_upper_coords, right_eye_lower_coords, (0, 255, 0), 2)
                    cv2.line(image, right_eye_inner_coords, right_eye_upper_coords, (0, 255, 255), 2)
                    cv2.line(image, right_eye_inner_coords, right_eye_lower_coords, (0, 255, 255), 2)
                    cv2.line(image, right_eye_outer_coords, right_eye_upper_coords, (0, 255, 255), 2)
                    cv2.line(image, right_eye_outer_coords, right_eye_lower_coords, (0, 255, 255), 2)

# Tính khoảng cách giữa môi trên và môi dưới
                    mouth_open_distance = np.linalg.norm(np.array(top_lip_coords) - np.array(bottom_lip_coords))

# Tính chiều cao của mắt trái và mắt phải (đã chuyển đổi sang pixel)
                    left_eye_height = abs(left_eye_upper_coords[1] - left_eye_lower_coords[1])
                    right_eye_height = abs(right_eye_upper_coords[1] - right_eye_lower_coords[1])

# Hiển thị giá trị chiều cao mắt để kiểm tra
                    cv2.putText(image, f"Left Eye: {left_eye_height:.2f}", (10, 30),
                                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
                    cv2.putText(image, f"Right Eye: {right_eye_height:.2f}", (10, 60),
                                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)

# Kiểm tra trạng thái mắt đóng/mở
                    eyes_closed = left_eye_height < 15 or right_eye_height < 15  # Ngưỡng 15 pixel

# Âm lượng = 0 nếu mắt nhắm, ngược lại điều chỉnh theo miệng
                    if eyes_closed:
                        volume_level = 0
                    else:
                        volume_level = np.interp(mouth_open_distance, [10, 80], [0, 100])
                    
                    # Điều chỉnh âm lượng
                    set_volume_mac(volume_level)

# Vẽ thanh âm lượng
                    draw_volume_bar(image, volume_level)

self.change_pixmap_signal.emit(image)
        self.cap.release()
        self.finished_signal.emit()

def stop(self):
        self._run_flag = False
        self.quit()
        self.wait()

class App(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Mouth Open Detection with Eye State Control")
        
        self.setMinimumSize(800, 600)
        self.disply_width = 800
        self.display_height = 600

self.image_label = QLabel(self)
        self.image_label.resize(self.disply_width, self.display_height)

self.start_button = QPushButton('Start')
        self.start_button.clicked.connect(self.start_video)
        self.stop_button = QPushButton('Stop')
        self.stop_button.clicked.connect(self.stop_video)

self.timer = QTimer()

vbox = QVBoxLayout()
        vbox.addWidget(self.image_label)
        vbox.addWidget(self.start_button)
        vbox.addWidget(self.stop_button)

widget = QWidget()
        widget.setLayout(vbox)
        self.setCentralWidget(widget)

self.thread = VideoThread()
        self.thread.change_pixmap_signal.connect(self.update_image)
        self.thread.finished_signal.connect(self.on_thread_finished)

def start_video(self):
        if not self.thread.isRunning():
            self.start_button.setEnabled(False)
            self.stop_button.setEnabled(True)
            self.thread.start()

def stop_video(self):
        if self.thread.isRunning():
            self.stop_button.setEnabled(False)
            self.thread.stop()

def on_thread_finished(self):
        self.start_button.setEnabled(True)

def closeEvent(self, event):
        self.thread.stop()
        event.accept()

@pyqtSlot(np.ndarray)
    def update_image(self, cv_img):
        qt_img = self.convert_cv_qt(cv_img)
        self.image_label.setPixmap(qt_img)

def convert_cv_qt(self, cv_img):
        rgb_image = cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB)
        h, w, ch = rgb_image.shape
        bytes_per_line = ch * w
        convert_to_Qt_format = QImage(rgb_image.data, w, h, bytes_per_line, QImage.Format_RGB888)
        p = convert_to_Qt_format.scaled(self.disply_width, self.display_height, Qt.KeepAspectRatio)
        return QPixmap.fromImage(p)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    a = App()
    a.show()
    sys.exit(app.exec_())

Preview: Sample code nghe nhạc cần há miệng, mở mắt

By me a coffee

<body>

@polyxgo

PolyXGO

Sample code mẫu Python này sử dụng theo dõi khuôn mặt thời gian thực để điều khiển âm lượng nhạc dựa trên cử chỉ khuôn mặt. Cụ thể:

Âm lượng tăng dần theo độ mở của miệng người dùng.
Nhạc sẽ tắt khi mắt nhắm lại.
Giao diện hiển thị video từ webcam kèm theo các điểm nhận diện khuôn mặt, phần trăm âm lượng và thanh hiển thị âm lượng theo chiều dọc.
Sử dụng MediaPipe để phát hiện mesh khuôn mặt, PyQt5 để xây dựng giao diện người dùng, và OpenCV để xử lý hình ảnh.
Tương thích với macOS (sử dụng osascript để điều chỉnh âm lượng). Trên Windows có thể cần cấu hình thêm.

Ứng dụng được xây dựng với mục đích học tập và thử nghiệm. Trong thực tế, có thể mở rộng để:

Kiểm tra tình trạng mở/nhắm mắt nhằm phát hiện ngủ gật.
Theo dõi tần suất mở miệng — điều này có thể áp dụng trong một số lĩnh vực như:
- Hệ thống cảnh báo tự động.
- Thống kê số học sinh ngủ gật hoặc nói chuyện trong lớp học.
- Giám sát sự tập trung trong môi trường đào tạo hoặc nơi làm việc.

Ứng dụng cho thấy tiềm năng trong việc phát triển các hệ thống tương tác không tiếp xúc, đặc biệt trong giáo dục, y tế, và an toàn lao động.

Python

Preview: Sample code nghe nhạc cần há miệng, mở mắt

Đăng nhập

Đăng ký