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 for playing music that requires mouth open and eyes open

By me a coffee

<body>

@polyxgo

PolyXGO

This Python application utilizes real-time facial tracking to control music volume based on facial gestures. Specifically:

Volume increases as the user’s mouth opens wider.
Music stops when the eyes are closed.
The interface displays a live webcam feed with facial landmarks, volume percentage, and a vertical volume bar.
Uses MediaPipe for face mesh detection, PyQt5 for GUI, and OpenCV for image processing.
Compatible with macOS (using osascript for volume control). Windows may require additional setup.

This project is intended for educational and experimental purposes. In real-world applications, it can be extended to:

Monitor eye state to detect drowsiness.
Track mouth opening frequency — which can be useful in areas such as:
- Automatic warning systems
- Statistics on students sleeping or talking during class
- Monitoring focus in training or workplace environments

This application shows potential for developing contactless interactive systems, especially in education, healthcare, and occupational safety.

Python

Preview: Sample code for playing music that requires mouth open and eyes open

Login

Register