pyadas 0.1.0__py3-none-any.whl

pyadas/camera/core.py

@@ -0,0 +1,96 @@
+import cv2
+import time
+import mediapipe as mp
+from pyadas.perception.ear import get_ear_metrics
+from pyadas.perception.mar import get_mar_metric
+from pyadas.perception.head_pose import get_head_pose
+from pyadas.drowsiness.temporal import TemporalAnalyzer
+from pyadas.driver_state.state_estimator import DriverStateEstimator
+# NEW: Importar o Logger
+from pyadas.telemetry.logger import TelemetryLogger
+
+def test_camera_feed():
+    cap = cv2.VideoCapture(0)
+    p_time = 0
+
+    mp_face_mesh = mp.solutions.face_mesh
+    mp_drawing = mp.solutions.drawing_utils
+    mp_drawing_styles = mp.solutions.drawing_styles
+
+    face_mesh = mp_face_mesh.FaceMesh(
+        max_num_faces=1,
+        refine_landmarks=True,
+        min_detection_confidence=0.5,
+        min_tracking_confidence=0.5
+    )
+    
+    analyzer = TemporalAnalyzer(calibration_frames=100, perclos_window_frames=150)
+    state_estimator = DriverStateEstimator()
+    # NEW: Instanciar o gravador de telemetria
+    logger = TelemetryLogger(log_dir="data")
+    
+    print("Iniciando captura. Pressione 'q' para encerrar.")
+    
+    while cap.isOpened():
+        success, frame = cap.read()
+        if not success:
+            print("Failed to capture video. Check the camera connection.")
+            break
+            
+        frame = cv2.resize(frame, (1280, 720))
+        h_frame, w_frame, _ = frame.shape
+        
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = face_mesh.process(frame_rgb)
+        
+        c_time = time.time()
+        fps = 1 / (c_time - p_time) if (c_time - p_time) > 0 else 0
+        p_time = c_time
+        
+        if results.multi_face_landmarks:
+            for face_landmarks in results.multi_face_landmarks:
+                mp_drawing.draw_landmarks(
+                    image=frame,
+                    landmark_list=face_landmarks,
+                    connections=mp_face_mesh.FACEMESH_TESSELATION,
+                    landmark_drawing_spec=None,
+                    connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_tesselation_style()
+                )
+                
+                ear_left, ear_right, ear_avg = get_ear_metrics(face_landmarks, w_frame, h_frame)
+                mar = get_mar_metric(face_landmarks, w_frame, h_frame)
+                yaw, pitch, roll = get_head_pose(face_landmarks, w_frame, h_frame)
+                
+                analyzer.update(ear_avg, mar)
+                perclos = analyzer.get_perclos()
+                is_calibrated = analyzer.is_calibrated
+                calib_status = analyzer.get_calibration_status()
+                
+                current_state = state_estimator.estimate_state(is_calibrated, perclos, mar, yaw)
+                
+                # NEW: Gravar os dados da iteração atual no arquivo CSV
+                logger.log(fps, ear_left, ear_right, ear_avg, mar, perclos, yaw, pitch, roll, "UNKNOWN", current_state)
+                
+                # Display Metrics
+                cv2.putText(frame, f'EAR Avg: {ear_avg:.2f}', (20, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                cv2.putText(frame, f'MAR: {mar:.2f}', (20, 130), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 165, 255), 2)
+                cv2.putText(frame, f'Yaw: {yaw:.1f}', (1000, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)
+                
+                if is_calibrated:
+                    cv2.putText(frame, f'STATE: {current_state}', (20, 170), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 255), 2)
+                    cv2.putText(frame, f'PERCLOS: {perclos*100:.1f}%', (20, 210), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                else:
+                    cv2.putText(frame, f'Calibrating... {int(calib_status*100)}%', (20, 170), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
+                    cv2.putText(frame, f'STATE: {current_state}', (20, 210), cv2.FONT_HERSHEY_SIMPLEX, 1, (128, 128, 128), 2)
+        
+        cv2.putText(frame, f'FPS: {int(fps)}', (20, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+        cv2.imshow("pyadas - Hardware Test", frame)
+        
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    test_camera_feed()

pyadas/driver_state/state_estimator.py

@@ -0,0 +1,34 @@
+class DriverStateEstimator:
+    def __init__(self):
+        # Thresholds baseados nas métricas calculadas e calibração dinâmica
+        self.perclos_drowsy_threshold = 0.20       # > 20% do tempo de olhos fechados = sonolência
+        self.perclos_microsleep_threshold = 0.60   # > 60% = potencial microssono
+        self.mar_yawning_threshold = 0.40          # MAR alto
+        self.yaw_distracted_threshold = 30.0       # Cabeça virada mais que 30 graus
+
+    def estimate_state(self, is_calibrated, perclos, mar, yaw):
+        """
+        Determina o estado atual do motorista com base nas métricas consolidadas.
+        Prioriza estados críticos (Microsleep > Drowsy > Yawning > Distracted).
+        """
+        if not is_calibrated:
+            return "UNKNOWN"
+
+        state = "ALERT"
+
+        # 1. Distração (Prioridade baixa, a cabeça virada pode afetar MAR/EAR)
+        if abs(yaw) > self.yaw_distracted_threshold:
+             state = "DISTRACTED"
+             return state # Retorna cedo pois a rotação extrema distorce o cálculo dos olhos/boca
+
+        # 2. Bocejo
+        if mar > self.mar_yawning_threshold:
+            state = "YAWNING"
+
+        # 3. Sonolência / Fadiga (Sobrescreve bocejo se estiverem ocorrendo juntos)
+        if perclos >= self.perclos_microsleep_threshold:
+            state = "POTENTIAL_MICROSLEEP"
+        elif perclos >= self.perclos_drowsy_threshold:
+            state = "DROWSY"
+
+        return state

pyadas/drowsiness/temporal.py

@@ -0,0 +1,58 @@
+import collections
+import numpy as np
+
+class TemporalAnalyzer:
+    def __init__(self, calibration_frames=100, perclos_window_frames=150):
+        """
+        calibration_frames: Quantidade de frames para calcular o baseline inicial.
+        perclos_window_frames: Tamanho da janela deslizante para cálculo do PERCLOS.
+        """
+        self.calibration_frames = calibration_frames
+        self.perclos_window_frames = perclos_window_frames
+        
+        # Buffers circulares de histórico
+        self.ear_history = collections.deque(maxlen=perclos_window_frames)
+        self.mar_history = collections.deque(maxlen=perclos_window_frames)
+        
+        # Variáveis de Baseline (Calibração Dinâmica)
+        self.baseline_ear = 0.0
+        self.baseline_mar = 0.0
+        
+        # Controle de Estado
+        self.frames_processed = 0
+        self.is_calibrated = False
+
+    def update(self, ear, mar):
+        """Alimenta o buffer com as métricas do frame atual e verifica calibração."""
+        self.ear_history.append(ear)
+        self.mar_history.append(mar)
+        
+        if not self.is_calibrated:
+            self.frames_processed += 1
+            if self.frames_processed >= self.calibration_frames:
+                # Calcula a média do período de aquecimento
+                self.baseline_ear = float(np.mean(self.ear_history))
+                self.baseline_mar = float(np.mean(self.mar_history))
+                self.is_calibrated = True
+
+    def get_perclos(self, closure_threshold_ratio=0.6):
+        """
+        Calcula o PERCLOS (Percentage of Eye Closure).
+        O olho é considerado fechado se o EAR for menor que 60% do Baseline.
+        """
+        if not self.is_calibrated or len(self.ear_history) == 0:
+            return 0.0
+            
+        # O limiar não é fixo, é relativo ao rosto do motorista atual
+        threshold = self.baseline_ear * closure_threshold_ratio
+        
+        closed_frames = sum(1 for val in self.ear_history if val < threshold)
+        perclos = closed_frames / len(self.ear_history)
+        
+        return perclos
+
+    def get_calibration_status(self):
+        """Retorna o progresso da calibração (0.0 a 1.0)."""
+        if self.is_calibrated:
+            return 1.0
+        return self.frames_processed / self.calibration_frames

pyadas/perception/ear.py

@@ -0,0 +1,48 @@
+import math
+
+# MediaPipe Face Mesh indices for the eyes
+# Order: [Corner Inner/Outer, Top 1, Top 2, Corner Outer/Inner, Bottom 2, Bottom 1]
+RIGHT_EYE_INDICES = [33, 160, 158, 133, 153, 144]
+LEFT_EYE_INDICES = [362, 385, 387, 263, 373, 380]
+
+def _euclidean_distance(p1, p2):
+    """Calculates the 2D Euclidean distance between two points."""
+    return math.dist(p1, p2)
+
+def _calculate_single_eye_ear(eye_points):
+    """
+    Computes the Eye Aspect Ratio for a single eye.
+    Formula: EAR = (||p2-p6|| + ||p3-p5||) / (2 * ||p1-p4||)
+    """
+    # Vertical distances
+    v1 = _euclidean_distance(eye_points[1], eye_points[5])
+    v2 = _euclidean_distance(eye_points[2], eye_points[4])
+    
+    # Horizontal distance
+    h = _euclidean_distance(eye_points[0], eye_points[3])
+    
+    # Avoid division by zero in case of extreme tracking anomalies
+    if h == 0:
+        return 0.0
+        
+    ear = (v1 + v2) / (2.0 * h)
+    return ear
+
+def get_ear_metrics(face_landmarks, frame_width, frame_height):
+    """
+    Extracts the left, right, and average EAR from the detected face landmarks.
+    """
+    def _extract_pixel_coords(indices):
+        # Converts normalized coordinates (0.0 to 1.0) into absolute pixel values
+        return [(face_landmarks.landmark[i].x * frame_width, 
+                 face_landmarks.landmark[i].y * frame_height) for i in indices]
+
+    right_eye_coords = _extract_pixel_coords(RIGHT_EYE_INDICES)
+    left_eye_coords = _extract_pixel_coords(LEFT_EYE_INDICES)
+
+    ear_right = _calculate_single_eye_ear(right_eye_coords)
+    ear_left = _calculate_single_eye_ear(left_eye_coords)
+    
+    ear_avg = (ear_right + ear_left) / 2.0
+
+    return ear_left, ear_right, ear_avg

pyadas/perception/head_pose.py

@@ -0,0 +1,70 @@
+import cv2
+import numpy as np
+
+# Generic 3D face model coordinates
+# Points: Nose tip, Chin, Right Eye Outer, Left Eye Outer, Right Mouth, Left Mouth
+FACE_3D_MODEL_POINTS = np.array([
+    (0.0, 0.0, 0.0),             # Nose tip
+    (0.0, -330.0, -65.0),        # Chin
+    (225.0, 170.0, -135.0),      # Right eye outer corner
+    (-225.0, 170.0, -135.0),     # Left eye outer corner
+    (150.0, -150.0, -125.0),     # Right mouth corner
+    (-150.0, -150.0, -125.0)     # Left mouth corner
+], dtype=np.float64)
+
+# Corresponding MediaPipe landmark indices
+FACE_2D_INDICES = [1, 152, 33, 263, 61, 291]
+
+def get_head_pose(face_landmarks, frame_width, frame_height):
+    """
+    Estimates the head pose (Yaw, Pitch, Roll) using cv2.solvePnP.
+    Returns the angles in degrees.
+    """
+    image_points = []
+    for idx in FACE_2D_INDICES:
+        x = face_landmarks.landmark[idx].x * frame_width
+        y = face_landmarks.landmark[idx].y * frame_height
+        image_points.append((x, y))
+        
+    image_points = np.array(image_points, dtype=np.float64)
+    
+    # Fake camera internals (assuming no lens distortion for the prototype)
+    focal_length = frame_width
+    center = (frame_width / 2, frame_height / 2)
+    camera_matrix = np.array(
+        [[focal_length, 0, center[0]],
+         [0, focal_length, center[1]],
+         [0, 0, 1]], dtype=np.float64
+    )
+    dist_coeffs = np.zeros((4, 1))
+    
+    success, rotation_vector, translation_vector = cv2.solvePnP(
+        FACE_3D_MODEL_POINTS, image_points, camera_matrix, dist_coeffs, flags=cv2.SOLVEPNP_ITERATIVE
+    )
+    
+    if not success:
+        return 0.0, 0.0, 0.0
+        
+    # Convert rotation vector to rotation matrix
+    rotation_matrix, _ = cv2.Rodrigues(rotation_vector)
+    
+    # Decompose the projection matrix to extract Euler angles
+    proj_matrix = np.hstack((rotation_matrix, translation_vector))
+    _, _, _, _, _, _, euler_angles = cv2.decomposeProjectionMatrix(proj_matrix)
+    
+    pitch = euler_angles[0][0]
+    yaw = euler_angles[1][0]
+    roll = euler_angles[2][0]
+    
+    # Normalização de Gimbal Lock para o sistema de coordenadas do OpenCV
+    if pitch > 0:
+        pitch = 180 - pitch
+    else:
+        pitch = pitch + 180
+        
+    # Correção de espelhamento: se a matriz inverteu, corrigimos Yaw e Roll
+    if euler_angles[0][0] > 0:
+        yaw = -yaw
+        roll = -roll
+
+    return yaw, pitch, roll

pyadas/perception/mar.py

@@ -0,0 +1,35 @@
+import math
+
+# MediaPipe inner lip indices
+# Horizontal corners: 78 (left), 308 (right)
+# Vertical center: 13 (top), 14 (bottom)
+
+def _euclidean_distance(p1, p2):
+    """Calculates the 2D Euclidean distance between two points."""
+    return math.dist(p1, p2)
+
+def get_mar_metric(face_landmarks, frame_width, frame_height):
+    """
+    Computes the Mouth Aspect Ratio (MAR) using the inner lips.
+    Formula: MAR = ||p13 - p14|| / ||p78 - p308||
+    """
+    def _extract_pixel_coord(index):
+        return (face_landmarks.landmark[index].x * frame_width, 
+                face_landmarks.landmark[index].y * frame_height)
+
+    # Extract coordinates
+    p_left = _extract_pixel_coord(78)
+    p_right = _extract_pixel_coord(308)
+    p_top = _extract_pixel_coord(13)
+    p_bottom = _extract_pixel_coord(14)
+
+    # Calculate distances
+    horizontal_dist = _euclidean_distance(p_left, p_right)
+    vertical_dist = _euclidean_distance(p_top, p_bottom)
+    
+    # Avoid division by zero
+    if horizontal_dist == 0:
+        return 0.0
+        
+    mar = vertical_dist / horizontal_dist
+    return mar

pyadas/pyadas_global.py

@@ -0,0 +1,23 @@
+import sys
+from PySide6.QtWidgets import QApplication
+from pyadas.ui.main_window import MainWindow
+
+def pyadasGui():
+    """
+    Função principal de inicialização da interface gráfica do pyadas.
+    Cria a instância do QApplication e exibe a MainWindow.
+    """
+    # Verifica se já existe uma instância do QApplication (útil se rodar via Jupyter no futuro)
+    app = QApplication.instance()
+    if not app:
+        app = QApplication(sys.argv)
+    
+    window = MainWindow()
+    window.show()
+    
+    # Inicia o loop de eventos da interface gráfica
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    # Permite que o arquivo seja testado rodando diretamente pelo terminal
+    pyadasGui()

pyadas/telemetry/logger.py

@@ -0,0 +1,46 @@
+import csv
+import time
+import os
+from datetime import datetime
+
+class TelemetryLogger:
+    def __init__(self, log_dir="data"):
+        # Garante que a pasta de destino exista
+        os.makedirs(log_dir, exist_ok=True)
+        
+        # Cria um arquivo com timestamp para não sobrescrever sessões antigas
+        timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.filepath = os.path.join(log_dir, f"session_{timestamp_str}.csv")
+        
+        self.headers = [
+            "timestamp", "fps", "ear_left", "ear_right", "ear_average",
+            "mar", "perclos", "yaw", "pitch", "roll", "gaze_direction", "driver_state"
+        ]
+        
+        # Inicializa o arquivo e escreve o cabeçalho
+        with open(self.filepath, mode='w', newline='') as file:
+            writer = csv.writer(file)
+            writer.writerow(self.headers)
+
+    def log(self, fps, ear_l, ear_r, ear_avg, mar, perclos, yaw, pitch, roll, gaze, state):
+        """Grava uma nova linha de telemetria no arquivo."""
+        current_timestamp = time.time()
+        row = [
+            f"{current_timestamp:.3f}",
+            int(fps),
+            f"{ear_l:.3f}",
+            f"{ear_r:.3f}",
+            f"{ear_avg:.3f}",
+            f"{mar:.3f}",
+            f"{perclos:.3f}",
+            f"{yaw:.1f}",
+            f"{pitch:.1f}",
+            f"{roll:.1f}",
+            gaze,
+            state
+        ]
+        
+        # Abre em modo append para adicionar a linha sem apagar o histórico
+        with open(self.filepath, mode='a', newline='') as file:
+            writer = csv.writer(file)
+            writer.writerow(row)

pyadas/ui/main_window.py

@@ -0,0 +1,309 @@
+import cv2
+import time
+import mediapipe as mp
+import numpy as np
+
+from PySide6.QtCore import QThread, Signal, Qt
+from PySide6.QtGui import QImage, QPixmap, QFont
+# NEW: Importação do QComboBox para o seletor de câmera
+from PySide6.QtWidgets import (QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
+                               QLabel, QPushButton, QFrame, QGridLayout, QComboBox)
+
+from pyadas.perception.ear import get_ear_metrics
+from pyadas.perception.mar import get_mar_metric
+from pyadas.perception.head_pose import get_head_pose
+from pyadas.drowsiness.temporal import TemporalAnalyzer
+from pyadas.driver_state.state_estimator import DriverStateEstimator
+from pyadas.telemetry.logger import TelemetryLogger
+
+from PySide6.QtWidgets import (QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
+                               QLabel, QPushButton, QFrame, QGridLayout, QComboBox, 
+                               QCheckBox, QFileDialog)
+import os
+
+from PySide6.QtMultimedia import QMediaDevices
+class VideoAcquisitionThread(QThread):
+    frame_ready = Signal(QImage)
+    telemetry_ready = Signal(dict)
+
+    # NEW: O inicializador agora aceita o índice da câmera
+    def __init__(self, camera_index=0):
+        super().__init__()
+        self.running = False
+        self.camera_index = camera_index
+        
+        self.analyzer = TemporalAnalyzer(calibration_frames=100, perclos_window_frames=150)
+        self.state_estimator = DriverStateEstimator()
+        self.logger = TelemetryLogger(log_dir="data")
+        
+        self.mp_face_mesh = mp.solutions.face_mesh.FaceMesh(
+            max_num_faces=1, refine_landmarks=True,
+            min_detection_confidence=0.5, min_tracking_confidence=0.5
+        )
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.mp_drawing_styles = mp.solutions.drawing_styles
+
+    def run(self):
+        self.running = True
+        # NEW: Inicia a câmera com o índice escolhido na interface
+        cap = cv2.VideoCapture(self.camera_index)
+        p_time = 0
+
+        while self.running and cap.isOpened():
+            success, frame = cap.read()
+            if not success:
+                break
+                
+            frame = cv2.resize(frame, (1280, 720))
+            h_frame, w_frame, _ = frame.shape
+            
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            results = self.mp_face_mesh.process(frame_rgb)
+            
+            c_time = time.time()
+            fps = 1 / (c_time - p_time) if (c_time - p_time) > 0 else 0
+            p_time = c_time
+            
+            telemetry = {
+                "fps": int(fps), "ear": 0.0, "mar": 0.0, "perclos": 0.0,
+                "yaw": 0.0, "pitch": 0.0, "roll": 0.0,
+                "state": "NO_FACE", "calib_status": 0.0, "is_calibrated": False
+            }
+
+            if results.multi_face_landmarks:
+                for face_landmarks in results.multi_face_landmarks:
+                    self.mp_drawing.draw_landmarks(
+                        image=frame_rgb,
+                        landmark_list=face_landmarks,
+                        connections=mp.solutions.face_mesh.FACEMESH_TESSELATION,
+                        landmark_drawing_spec=None,
+                        connection_drawing_spec=self.mp_drawing_styles.get_default_face_mesh_tesselation_style()
+                    )
+                    
+                    ear_left, ear_right, ear_avg = get_ear_metrics(face_landmarks, w_frame, h_frame)
+                    mar = get_mar_metric(face_landmarks, w_frame, h_frame)
+                    yaw, pitch, roll = get_head_pose(face_landmarks, w_frame, h_frame)
+                    
+                    self.analyzer.update(ear_avg, mar)
+                    perclos = self.analyzer.get_perclos()
+                    is_calibrated = self.analyzer.is_calibrated
+                    calib_status = self.analyzer.get_calibration_status()
+                    
+                    current_state = self.state_estimator.estimate_state(is_calibrated, perclos, mar, yaw)
+                    
+                    # Adiciona a verificação do logger
+                    if self.logger is not None:
+                        self.logger.log(fps, ear_left, ear_right, ear_avg, mar, perclos, yaw, pitch, roll, "UNKNOWN", current_state)
+                                            
+                    telemetry.update({
+                        "ear": ear_avg, "mar": mar, "perclos": perclos,
+                        "yaw": yaw, "pitch": pitch, "roll": roll,
+                        "state": current_state, "calib_status": calib_status,
+                        "is_calibrated": is_calibrated
+                    })
+            
+            self.telemetry_ready.emit(telemetry)
+
+            h, w, ch = frame_rgb.shape
+            bytes_per_line = ch * w
+            q_img = QImage(frame_rgb.data, w, h, bytes_per_line, QImage.Format_RGB888)
+            self.frame_ready.emit(q_img)
+
+        cap.release()
+
+    def stop(self):
+        self.running = False
+        self.wait()
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("pyadas - Driver Monitoring System")
+        self.resize(1200, 700)
+        
+        self.log_directory = "data" # Diretório padrão
+        self.setup_ui()
+        self.video_thread = None
+
+    def setup_ui(self):
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QHBoxLayout(central_widget)
+        
+        # --- Lado Esquerdo: Câmera e Controles ---
+        cam_layout = QVBoxLayout()
+        self.lbl_video = QLabel("Câmera Desligada")
+        self.lbl_video.setAlignment(Qt.AlignCenter)
+        self.lbl_video.setStyleSheet("background-color: black; color: white; font-size: 20px;")
+        self.lbl_video.setMinimumSize(800, 600)
+        
+        control_layout = QHBoxLayout()
+        
+        self.combo_camera = QComboBox()
+
+        # NEW: Varredura dinâmica de câmeras conectadas
+        available_cameras = QMediaDevices.videoInputs()
+        if not available_cameras:
+            self.combo_camera.addItem("Nenhuma câmera detectada", 0)
+        else:
+            for idx, cam in enumerate(available_cameras):
+                # cam.description() pega o nome real da câmera no Windows
+                self.combo_camera.addItem(f"{cam.description()} (ID {idx})", idx)
+                
+        self.combo_camera.setMinimumHeight(45)
+        self.combo_camera.setStyleSheet("font-size: 14px;")
+        
+        self.btn_start = QPushButton("Start Monitoring")
+        self.btn_start.setMinimumHeight(45)
+        self.btn_start.setStyleSheet("font-weight: bold; font-size: 14px;")
+        self.btn_start.clicked.connect(self.toggle_monitoring)
+        
+        control_layout.addWidget(self.combo_camera, stretch=1)
+        control_layout.addWidget(self.btn_start, stretch=4)
+        
+        # NEW: Controles de Salvamento do CSV
+        csv_control_layout = QHBoxLayout()
+        
+        self.check_save_csv = QCheckBox("Gravar sessão em CSV")
+        self.check_save_csv.setChecked(True)
+        self.check_save_csv.setStyleSheet("font-size: 12px; font-weight: bold;")
+        
+        self.btn_choose_dir = QPushButton("Escolher Pasta")
+        self.btn_choose_dir.clicked.connect(self.choose_directory)
+        
+        self.lbl_dir_path = QLabel(f"Pasta Atual: {os.path.abspath(self.log_directory)}")
+        self.lbl_dir_path.setStyleSheet("font-size: 10px; color: gray;")
+        
+        csv_control_layout.addWidget(self.check_save_csv)
+        csv_control_layout.addWidget(self.btn_choose_dir)
+        csv_control_layout.addWidget(self.lbl_dir_path, stretch=1)
+        
+        cam_layout.addWidget(self.lbl_video, stretch=1)
+        cam_layout.addLayout(csv_control_layout)
+        cam_layout.addLayout(control_layout)
+        
+        # --- Lado Direito: Painel de Telemetria (RÍGIDO) ---
+        right_panel = QWidget()
+        right_panel.setFixedWidth(350)
+        panel_layout = QVBoxLayout(right_panel)
+        panel_layout.setSpacing(20)
+        panel_layout.setContentsMargins(10, 0, 0, 0)
+        
+        self.lbl_state = self._create_panel_label("STATE: IDLE", 24, bold=True)
+        self.lbl_state.setStyleSheet("color: gray;")
+        self.lbl_state.setWordWrap(True)
+        self.lbl_state.setMinimumHeight(70)
+        
+        self.lbl_calib = self._create_panel_label("Status: Waiting", 14)
+        
+        metrics_frame = QFrame()
+        metrics_frame.setFrameShape(QFrame.StyledPanel)
+        metrics_layout = QGridLayout(metrics_frame)
+        
+        self.lbl_ear = self._create_panel_label("EAR: 0.00")
+        self.lbl_mar = self._create_panel_label("MAR: 0.00")
+        self.lbl_perclos = self._create_panel_label("PERCLOS: 0.0%")
+        self.lbl_yaw = self._create_panel_label("Yaw: 0.0°")
+        self.lbl_fps = self._create_panel_label("FPS: 0")
+        
+        metrics_layout.addWidget(self.lbl_ear, 0, 0)
+        metrics_layout.addWidget(self.lbl_mar, 1, 0)
+        metrics_layout.addWidget(self.lbl_perclos, 2, 0)
+        metrics_layout.addWidget(self.lbl_yaw, 3, 0)
+        metrics_layout.addWidget(self.lbl_fps, 4, 0)
+        
+        panel_layout.addWidget(self.lbl_state)
+        panel_layout.addWidget(self.lbl_calib)
+        panel_layout.addWidget(metrics_frame)
+        panel_layout.addStretch()
+        
+        main_layout.addLayout(cam_layout, stretch=1)
+        main_layout.addWidget(right_panel)
+
+    def _create_panel_label(self, text, size=16, bold=False):
+        lbl = QLabel(text)
+        font = QFont("Arial", size)
+        font.setBold(bold)
+        lbl.setFont(font)
+        return lbl
+
+    def choose_directory(self):
+        dir_path = QFileDialog.getExistingDirectory(self, "Selecionar Pasta para Salvar CSV")
+        if dir_path:
+            self.log_directory = dir_path
+            self.lbl_dir_path.setText(f"Pasta Atual: {os.path.abspath(self.log_directory)}")
+
+    def toggle_monitoring(self):
+        if self.video_thread is None or not self.video_thread.isRunning():
+            # NEW: Pega o ID (userdata) correspondente à câmera selecionada
+            cam_idx = self.combo_camera.currentData()
+            
+            self.video_thread = VideoAcquisitionThread(camera_index=cam_idx)
+            
+            # Repassa a escolha do usuário para a thread de vídeo
+            if not self.check_save_csv.isChecked():
+                self.video_thread.logger = None # Desliga o logger se a checkbox estiver desmarcada
+            else:
+                 self.video_thread.logger = TelemetryLogger(log_dir=self.log_directory)
+            
+            self.video_thread.frame_ready.connect(self.update_image)
+            self.video_thread.telemetry_ready.connect(self.update_telemetry)
+            self.video_thread.start()
+            
+            self.combo_camera.setEnabled(False)
+            self.check_save_csv.setEnabled(False)
+            self.btn_choose_dir.setEnabled(False)
+            self.btn_start.setText("Stop Monitoring")
+            self.btn_start.setStyleSheet("background-color: #ff4c4c; font-weight: bold; font-size: 14px;")
+        else:
+            self.video_thread.stop()
+            self.combo_camera.setEnabled(True)
+            self.check_save_csv.setEnabled(True)
+            self.btn_choose_dir.setEnabled(True)
+            self.btn_start.setText("Start Monitoring")
+            self.btn_start.setStyleSheet("font-weight: bold; font-size: 14px;")
+            self.lbl_video.clear()
+            self.lbl_video.setText("Câmera Desligada")
+            self.lbl_state.setText("STATE: IDLE")
+            self.lbl_state.setStyleSheet("color: gray;")
+
+    def update_image(self, q_img):
+        pixmap = QPixmap.fromImage(q_img).scaled(
+            self.lbl_video.width(), self.lbl_video.height(), Qt.KeepAspectRatio
+        )
+        self.lbl_video.setPixmap(pixmap)
+
+    def update_telemetry(self, data):
+        self.lbl_ear.setText(f"EAR: {data['ear']:.2f}")
+        self.lbl_mar.setText(f"MAR: {data['mar']:.2f}")
+        self.lbl_perclos.setText(f"PERCLOS: {data['perclos']*100:.1f}%")
+        self.lbl_yaw.setText(f"Yaw: {data['yaw']:.1f}°")
+        self.lbl_fps.setText(f"FPS: {data['fps']}")
+        
+        if data['is_calibrated']:
+            self.lbl_calib.setText("Status: CALIBRATED")
+            self.lbl_calib.setStyleSheet("color: green; font-weight: bold;")
+        else:
+            pct = int(data['calib_status'] * 100)
+            self.lbl_calib.setText(f"Calibrating... {pct}%")
+            self.lbl_calib.setStyleSheet("color: orange; font-weight: bold;")
+            
+        state = data['state']
+
+        state_display = state.replace("_", " ") 
+        self.lbl_state.setText(f"STATE:\n{state_display}")
+        
+        if state == "ALERT":
+            self.lbl_state.setStyleSheet("color: green;")
+        elif state in ["DROWSY", "YAWNING", "DISTRACTED"]:
+            self.lbl_state.setStyleSheet("color: orange;")
+        elif state == "POTENTIAL_MICROSLEEP":
+            self.lbl_state.setStyleSheet("color: red;")
+        else:
+            self.lbl_state.setStyleSheet("color: gray;")
+            
+    def closeEvent(self, event):
+        if self.video_thread is not None and self.video_thread.isRunning():
+            self.video_thread.stop()
+        event.accept()

pyadas-0.1.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: pyadas
+Version: 0.1.0
+Summary: Open-Source Driver Monitoring System
+Requires-Python: <3.12,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python
+Requires-Dist: mediapipe==0.10.14
+Requires-Dist: PySide6
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file
+
+# pyadas 🚘📹
+
+[![PyPI version](https://img.shields.io/pypi/v/pyadas.svg)](https://pypi.org/project/pyadas/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pyadas.svg)](https://pypi.org/project/pyadas/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**pyadas** is a real-time Driver Monitoring System (DMS) tailored for Advanced Driver Assistance Systems (ADAS) applications.
+
+Built purely in Python, the project leverages asynchronous processing (via PySide6), computer vision, and facial geometry (via MediaPipe and OpenCV) to estimate attention, distraction, and fatigue states in real time using conventional hardware (webcams).
+
+> **Important Notice:** This is a software engineering and research prototype. It is **not** a diagnostic medical device and holds **no** certifications to act as a production vehicular safety system.
+
+---
+
+## 📋 Table of Contents
+1. [Key Features](#-key-features)
+2. [Driver State Estimator](#%EF%B8%8F-driver-state-estimator)
+3. [Installation](#-installation)
+4. [Usage](#-usage)
+5. [Contact](#-contact)
+
+---
+
+## 🚀 Key Features
+
+*   **Dynamic Calibration (Auto-Baseline):** The system relies on no universal hardcoded thresholds. It autonomously calibrates the driver's facial averages within the first few seconds of initialization.
+*   **Fatigue Estimation:** Continuous calculation of the Eye Aspect Ratio (EAR).
+*   **Temporal Analysis (PERCLOS):** Implementation of the Percentage of Eye Closure metric via a high-performance sliding window for robust drowsiness and potential microsleep detection, bypassing normal blinking false positives.
+*   **Yawn Detection:** Mouth Aspect Ratio (MAR) calculation.
+*   **Gaze & Pose Estimation:** Approximate calculation of the head's Yaw, Pitch, and Roll angles.
+*   **Asynchronous & Responsive UI:** Multi-threaded architecture isolating heavy video acquisition from the graphical user interface built with PySide6.
+*   **Telemetry (Black-box logger):** Continuous CSV log recording (EAR, MAR, PERCLOS, FPS, Angles, Driver State) for post-processing and mathematical data cross-referencing.
+
+## ⚙️ Driver State Estimator
+
+The package architecture cross-references geometric and temporal metrics to classify the driver into critical categories:
+*   `ALERT`: Normal active visual state.
+*   `DISTRACTED`: Prolonged head rotation outside the region of interest.
+*   `YAWNING`: Temporal events of severe mouth opening (MAR > threshold).
+*   `DROWSY`: Drowsiness indicator triggered when PERCLOS exceeds primary safety levels.
+*   `POTENTIAL_MICROSLEEP`: Detection of severe, sustained eye closure over the temporal window.
+
+## 💻 Installation
+
+```console
+pip install pyadas
+```
+
+## 🛠️ Usage
+
+### Starting the GUI
+
+```python
+from pyadas.pyadas_global import pyadasGui
+
+pyadasGui()
+```
+
+## ✉️ Contact
+
+Cayo Rawlisom Castoril - [LinkedIn](https://www.linkedin.com/in/cayo-rawlisom-407816247/) | cayorwcs@gmail.com
+
+Project Link: [https://github.com/CayoRw/pyadas](https://github.com/CayoRw/pyadas)

pyadas-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pyadas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyadas/pyadas_global.py,sha256=5u8W8e4c54IsSe3fgP34rdcPVBXPu8IdLStlT02oNbE,726
+pyadas/camera/core.py,sha256=jDR39qU3sIZVJcrnC6bIGBe3Jcw9lTvQBwCc19lh1r0,4332
+pyadas/driver_state/state_estimator.py,sha256=oxY5numXrT71vZl9lUDtf3hLqmkA6ZdKceoeTHlxue4,1490
+pyadas/drowsiness/temporal.py,sha256=gE7pHNYEpeun_cUQGvBJyWHQiyL2d3FcYCkvDPlsQYY,2371
+pyadas/perception/ear.py,sha256=7zv2Esb3VapQZaP77TkAxXK8HgX4blexug39wX8VTUU,1743
+pyadas/perception/head_pose.py,sha256=ch68E4IjkSWLdn3d45egq7BVgM7FHFo2q2WKz6-r_vI,2477
+pyadas/perception/mar.py,sha256=Agb9nbipP8voeipApxfiGk7D1d-QXnCeoS94jZx-yl0,1126
+pyadas/telemetry/logger.py,sha256=ZL6Ehdp7BGyuCdnCs-1nlm4U_hIIRHk8RnuQWRg26Vg,1667
+pyadas/ui/main_window.py,sha256=botxoTQON48pbmilcJOuKPhGyntz-joQs5hBBJdYjA0,13609
+pyadas-0.1.0.dist-info/licenses/LICENSE,sha256=pFQG-1jQwbfWdk37f429_CRc3QObJiga_MIf8RWnCN4,1091
+pyadas-0.1.0.dist-info/METADATA,sha256=BMsFI0osmZ56RJZLsXJUUpOReA4SExRuqU1_iDnnFRM,3486
+pyadas-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyadas-0.1.0.dist-info/top_level.txt,sha256=CIcxWpeMb2HEZT_GXLXgHf3y0VNo6W-dahc6LP3ZXIQ,7
+pyadas-0.1.0.dist-info/RECORD,,

pyadas-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyadas-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cayo Rawlisom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyadas-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyadas