WIP: Quick demo for project

ai_alert_generator.py

@@ -0,0 +1,214 @@
+import google.generativeai as genai
+import numpy as np
+from scipy.io import wavfile
+import tempfile
+import os
+
+from facial_detection import OpenCVFaceDetector, MetricsCalculator, DrowsinessAnalyzer, AlertManager, VisualizationRenderer, StatusLogger
+
+class AIAlertGenerator:
+    """Generate AI-powered voice alerts using Gemini"""
+    
+    def __init__(self, api_key=None):
+        self.model = None
+        if api_key:
+            try:
+                genai.configure(api_key=api_key)
+                self.model = genai.GenerativeModel('gemini-1.5-flash')
+                print("✅ Gemini AI initialized for voice alerts")
+            except Exception as e:
+                print(f"⚠️ Failed to initialize Gemini: {e}")
+    
+    def generate_alert_text(self, alert_type, severity="medium"):
+        """Generate contextual alert text using Gemini"""
+        if not self.model:
+            return self._get_default_alert_text(alert_type, severity)
+        
+        try:
+            prompts = {
+                "EYES_CLOSED": f"Generate a brief, urgent wake-up message (max 12 words) for a drowsy driver whose eyes are closing. Severity: {severity}. Sound caring but firm.",
+                "YAWNING": f"Generate a brief, gentle alert (max 10 words) for a driver who is yawning frequently. Severity: {severity}. Sound encouraging.",
+                "HEAD_NOD": f"Generate a brief, firm alert (max 10 words) for a driver whose head is nodding. Severity: {severity}. Sound urgent but supportive.",
+                "COMBINED": f"Generate a brief, critical alert (max 15 words) for a driver showing multiple drowsiness signs. Severity: {severity}. Sound very urgent but caring."
+            }
+            
+            prompt_key = "COMBINED" if isinstance(alert_type, list) and len(alert_type) > 1 else alert_type[0] if isinstance(alert_type, list) else alert_type
+            prompt = prompts.get(prompt_key, prompts["EYES_CLOSED"])
+            
+            response = self.model.generate_content(prompt)
+            alert_text = response.text.strip().replace('"', '').replace("'", "")
+            
+            return alert_text[:100]
+            
+        except Exception as e:
+            print(f"Error generating AI alert: {e}")
+            return self._get_default_alert_text(alert_type, severity)
+    
+    def _get_default_alert_text(self, alert_type, severity):
+        """Fallback alert messages"""
+        default_alerts = {
+            "EYES_CLOSED": {
+                "critical": "WAKE UP NOW! Pull over immediately!",
+                "high": "Eyes closing! Stay alert and pull over soon!",
+                "medium": "Please keep your eyes open while driving!"
+            },
+            "YAWNING": {
+                "critical": "Excessive yawning detected! Take a break!",
+                "high": "You seem tired. Consider resting soon.",
+                "medium": "Frequent yawning noticed. Stay alert!"
+            },
+            "HEAD_NOD": {
+                "critical": "Head nodding detected! Stop driving now!",
+                "high": "Your head is nodding. Pull over safely!",
+                "medium": "Head movement detected. Stay focused!"
+            }
+        }
+        
+        alert_key = alert_type[0] if isinstance(alert_type, list) else alert_type
+        return default_alerts.get(alert_key, {}).get(severity, "Stay alert while driving!")
+    
+    def create_audio_alert(self, text, sample_rate=22050):
+        """Create audio alert (generates beep pattern)"""
+        try:
+            duration = 2.0
+            freq = 800
+            frames = int(duration * sample_rate)
+            
+            # Create attention-grabbing beep pattern
+            t = np.linspace(0, duration, frames)
+            beep1 = np.sin(2 * np.pi * freq * t) * np.exp(-t * 3)
+            beep2 = np.sin(2 * np.pi * (freq * 1.5) * t) * np.exp(-t * 3)
+            
+            # Combine beeps with pause
+            silence = np.zeros(int(0.1 * sample_rate))
+            audio = np.concatenate([beep1, silence, beep2, silence, beep1])
+            
+            # Normalize and convert to int16
+            audio = (audio * 32767).astype(np.int16)
+            
+            # Save to temporary file
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.wav')
+            wavfile.write(temp_file.name, sample_rate, audio)
+            
+            return temp_file.name, text
+            
+        except Exception as e:
+            print(f"Error creating audio alert: {e}")
+            return None, text
+
+class DrowsinessDetectionSystem:
+    """Main system coordinator"""
+    
+    def __init__(self):
+        self.face_detector = OpenCVFaceDetector()
+        self.metrics_calculator = MetricsCalculator()
+        self.drowsiness_analyzer = DrowsinessAnalyzer()
+        self.alert_manager = AlertManager()
+        self.visualization_renderer = VisualizationRenderer()
+        self.logger = StatusLogger()
+        
+        print("✅ Drowsiness Detection System initialized with OpenCV")
+        
+    def process_frame(self, frame):
+        """Process a single frame and return results"""
+        try:
+            # Detect face and landmarks
+            face_rects, landmarks_list = self.face_detector.detect_landmarks(frame)
+            
+            if not face_rects or not landmarks_list:
+                self.logger.log("No face detected")
+                return frame, ["👤 No face detected"], False, {}
+            
+            # Process first detected face
+            face_rect = face_rects[0]
+            landmarks = landmarks_list[0]
+            
+            # Calculate metrics
+            ear_left = ear_right = 0.25  # Default values
+            
+            if 'left_eye_corners' in landmarks:
+                ear_left = self.metrics_calculator.calculate_ear_from_points(landmarks['left_eye_corners'])
+            if 'right_eye_corners' in landmarks:
+                ear_right = self.metrics_calculator.calculate_ear_from_points(landmarks['right_eye_corners'])
+            
+            ear = (ear_left + ear_right) / 2.0
+            
+            mar = 0.3  # Default value
+            if 'mouth_corners' in landmarks:
+                mar = self.metrics_calculator.calculate_mar_from_points(landmarks['mouth_corners'])
+            
+            # Head pose estimation
+            frame_center = (frame.shape[1] // 2, frame.shape[0] // 2)
+            head_angles = self.metrics_calculator.estimate_head_pose_simple(
+                landmarks.get('nose_tip'), 
+                landmarks.get('chin'), 
+                frame_center
+            )
+            
+            # Analyze drowsiness
+            indicators = self.drowsiness_analyzer.analyze_drowsiness(ear, mar, head_angles)
+            severity = self.drowsiness_analyzer.get_severity_level(indicators)
+            
+            # Check for alerts
+            should_alert = self.alert_manager.should_trigger_alert(indicators)
+            
+            # Render visualization
+            self.visualization_renderer.draw_landmarks_and_contours(frame, landmarks, face_rect)
+            self.visualization_renderer.draw_metrics_overlay(frame, ear, mar, head_angles[0], indicators)
+            
+            # Generate status text
+            status_text = self._generate_status_text(ear, mar, head_angles[0], indicators)
+            
+            # Log events
+            if indicators:
+                self.logger.log(f"Drowsiness detected: {', '.join(indicators)} (Severity: {severity})")
+            
+            # Prepare metrics
+            metrics = {
+                'ear': ear,
+                'mar': mar,
+                'head_angle': head_angles[0],
+                'indicators': indicators,
+                'severity': severity
+            }
+            
+            return frame, status_text, should_alert, metrics
+            
+        except Exception as e:
+            error_msg = f"Error processing frame: {str(e)}"
+            self.logger.log(error_msg)
+            return frame, [error_msg], False, {}
+    
+    def _generate_status_text(self, ear, mar, head_angle, indicators):
+        """Generate human-readable status text"""
+        status = []
+        
+        # EAR status
+        if ear < self.drowsiness_analyzer.EAR_THRESHOLD:
+            status.append(f"👁️ Eyes closing! EAR: {ear:.3f}")
+        else:
+            status.append(f"👁️ Eyes open - EAR: {ear:.3f}")
+        
+        # MAR status
+        if mar > self.drowsiness_analyzer.YAWN_THRESHOLD:
+            status.append(f"🥱 Yawning detected! MAR: {mar:.3f}")
+        else:
+            status.append(f"👄 Normal mouth - MAR: {mar:.3f}")
+        
+        # Head pose status
+        if abs(head_angle) > self.drowsiness_analyzer.NOD_THRESHOLD:
+            status.append(f"📉 Head nodding! Angle: {head_angle:.1f}°")
+        else:
+            status.append(f"📏 Head pose normal - Pitch: {head_angle:.1f}°")
+        
+        # Overall status
+        if indicators:
+            status.append(f"⚠️ ALERT: {', '.join(indicators)}")
+        else:
+            status.append("✅ Driver appears alert")
+        
+        return status
+    
+    def get_logs(self):
+        """Get recent system logs"""
+        return "\n".join(self.logger.get_recent_logs())

app.py

@@ -1,457 +1,209 @@
-import cv2
-import numpy as np
-import dlib
-import gradio as gr
-import threading
-import time
-import queue
-import pygame
-import io
-import google.generativeai as genai
-from scipy.spatial import distance as dist
-from collections import deque
-import tempfile
+# main.py
 import os
-from datetime import datetime
+import sys
+from gradio_interface import GradioWebRTCInterface
+from dotenv import load_dotenv
 
-class DrowsinessDetector:
-    def __init__(self, gemini_api_key=None):
-        # Initialize face detector and landmark predictor
-        self.detector = dlib.get_frontal_face_detector()
-        self.predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
-        
-        # EAR (Eye Aspect Ratio) parameters
-        self.EAR_THRESHOLD = 0.25
-        self.EAR_CONSECUTIVE_FRAMES = 20
-        self.ear_counter = 0
-        self.ear_history = deque(maxlen=30)
-        
-        # Yawn detection parameters
-        self.YAWN_THRESHOLD = 0.6
-        self.YAWN_CONSECUTIVE_FRAMES = 15
-        self.yawn_counter = 0
-        self.yawn_history = deque(maxlen=30)
-        
-        # Head pose estimation parameters
-        self.NOD_THRESHOLD = 15
-        self.nod_counter = 0
-        self.head_pose_history = deque(maxlen=30)
-        
-        # Alert system
-        self.drowsy_alert = False
-        self.last_alert_time = 0
-        self.alert_cooldown = 10  # seconds
-        
-        # Initialize pygame for audio
-        pygame.mixer.init()
-        
-        # Initialize Gemini AI
-        if gemini_api_key:
-            genai.configure(api_key=gemini_api_key)
-            self.model = genai.GenerativeModel('gemini-pro')
-        else:
-            self.model = None
-        
-        # Eye and mouth landmark indices
-        self.LEFT_EYE = list(range(36, 42))
-        self.RIGHT_EYE = list(range(42, 48))
-        self.MOUTH = list(range(48, 68))
-        
-        # 3D model points for head pose estimation
-        self.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),     # Left eye left corner
-            (225.0, 170.0, -135.0),      # Right eye right corner
-            (-150.0, -150.0, -125.0),    # Left Mouth corner
-            (150.0, -150.0, -125.0)      # Right mouth corner
-        ])
-        
-        self.status_log = deque(maxlen=100)
-        
-    def calculate_ear(self, eye_landmarks):
-        """Calculate Eye Aspect Ratio"""
-        # Vertical eye landmarks
-        A = dist.euclidean(eye_landmarks[1], eye_landmarks[5])
-        B = dist.euclidean(eye_landmarks[2], eye_landmarks[4])
-        # Horizontal eye landmark
-        C = dist.euclidean(eye_landmarks[0], eye_landmarks[3])
-        # EAR calculation
-        ear = (A + B) / (2.0 * C)
-        return ear
-    
-    def calculate_mar(self, mouth_landmarks):
-        """Calculate Mouth Aspect Ratio for yawn detection"""
-        # Vertical mouth landmarks
-        A = dist.euclidean(mouth_landmarks[2], mouth_landmarks[10])  # 50, 58
-        B = dist.euclidean(mouth_landmarks[4], mouth_landmarks[8])   # 52, 56
-        # Horizontal mouth landmark
-        C = dist.euclidean(mouth_landmarks[0], mouth_landmarks[6])   # 48, 54
-        # MAR calculation
-        mar = (A + B) / (2.0 * C)
-        return mar
-    
-    def get_head_pose(self, landmarks, img_size):
-        """Estimate head pose using facial landmarks"""
-        image_points = np.array([
-            (landmarks[30][0], landmarks[30][1]),     # Nose tip
-            (landmarks[8][0], landmarks[8][1]),       # Chin
-            (landmarks[36][0], landmarks[36][1]),     # Left eye left corner
-            (landmarks[45][0], landmarks[45][1]),     # Right eye right corner
-            (landmarks[48][0], landmarks[48][1]),     # Left Mouth corner
-            (landmarks[54][0], landmarks[54][1])      # Right mouth corner
-        ], dtype="double")
-        
-        # Camera internals
-        focal_length = img_size[1]
-        center = (img_size[1]/2, img_size[0]/2)
-        camera_matrix = np.array([
-            [focal_length, 0, center[0]],
-            [0, focal_length, center[1]],
-            [0, 0, 1]], dtype="double")
-        
-        dist_coeffs = np.zeros((4,1)) # Assuming no lens distortion
-        
-        # Solve PnP
-        (success, rotation_vector, translation_vector) = cv2.solvePnP(
-            self.model_points, image_points, camera_matrix, dist_coeffs, 
-            flags=cv2.SOLVEPNP_ITERATIVE)
-        
-        # Convert rotation vector to rotation matrix
-        (rotation_matrix, jacobian) = cv2.Rodrigues(rotation_vector)
-        
-        # Calculate Euler angles
-        sy = np.sqrt(rotation_matrix[0,0] * rotation_matrix[0,0] +  rotation_matrix[1,0] * rotation_matrix[1,0])
-        singular = sy < 1e-6
-        if not singular:
-            x = np.arctan2(rotation_matrix[2,1], rotation_matrix[2,2])
-            y = np.arctan2(-rotation_matrix[2,0], sy)
-            z = np.arctan2(rotation_matrix[1,0], rotation_matrix[0,0])
-        else:
-            x = np.arctan2(-rotation_matrix[1,2], rotation_matrix[1,1])
-            y = np.arctan2(-rotation_matrix[2,0], sy)
-            z = 0
-        
-        # Convert to degrees
-        angles = np.array([x, y, z]) * 180.0 / np.pi
-        return angles
+load_dotenv()
+
+def check_opencv_installation():
+    """Check if OpenCV is properly installed with required cascades"""
+    try:
+        import cv2
+        
+        # Check for required cascade files
+        cascade_files = [
+            'haarcascade_frontalface_default.xml',
+            'haarcascade_eye.xml',
+            'haarcascade_smile.xml'
+        ]
+        
+        missing_cascades = []
+        for cascade in cascade_files:
+            cascade_path = cv2.data.haarcascades + cascade
+            if not os.path.exists(cascade_path):
+                missing_cascades.append(cascade)
+        
+        if missing_cascades:
+            print(f"❌ Missing OpenCV cascade files: {missing_cascades}")
+            print("💡 Please reinstall OpenCV: pip install opencv-python")
+            return False
+        
+        print("✅ OpenCV and required cascade files found!")
+        return True
+        
+    except ImportError:
+        print("❌ OpenCV not found. Please install: pip install opencv-python")
+        return False
+
+def check_optional_dependencies():
+    """Check for optional dependencies and provide info"""
+    optional_deps = {
+        'mediapipe': 'Enhanced facial landmark detection',
+        'google.generativeai': 'AI-powered voice alerts',
+        'scipy': 'Advanced mathematical computations'
+    }
     
-    def generate_voice_alert(self, alert_type, severity="medium"):
-        """Generate voice alert using Gemini AI"""
-        if not self.model:
-            return self.play_default_alert()
-        
-        try:
-            prompts = {
-                "drowsy": f"Generate a brief, urgent but caring voice alert (max 15 words) to wake up a drowsy driver. Severity: {severity}. Make it sound natural and concerned.",
-                "yawn": f"Generate a brief, gentle voice alert (max 12 words) for a driver who is yawning frequently. Severity: {severity}. Sound caring but alert.",
-                "nod": f"Generate a brief, firm voice alert (max 12 words) for a driver whose head is nodding. Severity: {severity}. Sound urgent but supportive."
-            }
-            
-            response = self.model.generate_content(prompts.get(alert_type, prompts["drowsy"]))
-            alert_text = response.text.strip().replace('"', '').replace("'", "")
-            
-            # Use text-to-speech (you would need to install pyttsx3 or use cloud TTS)
-            # For this example, we'll use a placeholder
-            self.log_status(f"🔊 ALERT: {alert_text}")
-            return alert_text
-            
-        except Exception as e:
-            self.log_status(f"Error generating alert: {str(e)}")
-            return self.play_default_alert()
+    available = []
+    missing = []
     
-    def play_default_alert(self):
-        """Play default beep alert"""
+    for dep, description in optional_deps.items():
         try:
-            # Generate a simple beep sound
-            duration = 0.5  # seconds
-            freq = 800  # Hz
-            sample_rate = 22050
-            frames = int(duration * sample_rate)
-            arr = np.zeros(frames)
-            
-            for i in range(frames):
-                arr[i] = np.sin(2 * np.pi * freq * i / sample_rate)
-            
-            arr = (arr * 32767).astype(np.int16)
-            sound = pygame.sndarray.make_sound(arr)
-            sound.play()
-            
-            alert_text = "⚠️ WAKE UP! Please stay alert while driving!"
-            self.log_status(f"🔊 {alert_text}")
-            return alert_text
-            
-        except Exception as e:
-            self.log_status(f"Error playing alert: {str(e)}")
-            return "Alert system activated"
+            __import__(dep)
+            available.append(f"✅ {dep} - {description}")
+        except ImportError:
+            missing.append(f"⚪ {dep} - {description}")
     
-    def log_status(self, message):
-        """Log status messages with timestamp"""
-        timestamp = datetime.now().strftime("%H:%M:%S")
-        self.status_log.append(f"[{timestamp}] {message}")
+    if available:
+        print("📦 Available optional features:")
+        for item in available:
+            print(f"   {item}")
     
-    def detect_drowsiness(self, frame):
-        """Main drowsiness detection function"""
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        faces = self.detector(gray)
-        
-        status_text = []
-        alert_message = ""
-        
-        if len(faces) == 0:
-            status_text.append("👤 No face detected")
-            self.log_status("No face detected in frame")
-            return frame, status_text, alert_message
-        
-        for face in faces:
-            landmarks = self.predictor(gray, face)
-            landmarks = np.array([[p.x, p.y] for p in landmarks.parts()])
-            
-            # Draw face rectangle
-            x, y, w, h = face.left(), face.top(), face.width(), face.height()
-            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
-            
-            # Eye Aspect Ratio calculation
-            left_eye = landmarks[self.LEFT_EYE]
-            right_eye = landmarks[self.RIGHT_EYE]
-            
-            left_ear = self.calculate_ear(left_eye)
-            right_ear = self.calculate_ear(right_eye)
-            ear = (left_ear + right_ear) / 2.0
-            self.ear_history.append(ear)
-            
-            # Draw eye contours
-            cv2.drawContours(frame, [cv2.convexHull(left_eye)], -1, (0, 255, 0), 1)
-            cv2.drawContours(frame, [cv2.convexHull(right_eye)], -1, (0, 255, 0), 1)
-            
-            # Yawn detection
-            mouth = landmarks[self.MOUTH]
-            mar = self.calculate_mar(mouth)
-            self.yawn_history.append(mar)
-            
-            # Draw mouth contour
-            cv2.drawContours(frame, [cv2.convexHull(mouth)], -1, (0, 255, 255), 1)
-            
-            # Head pose estimation
-            head_angles = self.get_head_pose(landmarks, frame.shape)
-            self.head_pose_history.append(head_angles[0])  # Pitch angle
-            
-            # Drowsiness detection logic
-            drowsy_indicators = []
-            
-            # Check EAR
-            if ear < self.EAR_THRESHOLD:
-                self.ear_counter += 1
-                if self.ear_counter >= self.EAR_CONSECUTIVE_FRAMES:
-                    drowsy_indicators.append("EYES_CLOSED")
-                    status_text.append(f"👁️ Eyes closed! EAR: {ear:.3f}")
-            else:
-                self.ear_counter = 0
-                status_text.append(f"👁️ Eyes open - EAR: {ear:.3f}")
-            
-            # Check for yawning
-            if mar > self.YAWN_THRESHOLD:
-                self.yawn_counter += 1
-                if self.yawn_counter >= self.YAWN_CONSECUTIVE_FRAMES:
-                    drowsy_indicators.append("YAWNING")
-                    status_text.append(f"🥱 Yawning detected! MAR: {mar:.3f}")
-            else:
-                self.yawn_counter = 0
-                status_text.append(f"👄 Normal mouth - MAR: {mar:.3f}")
-            
-            # Check head nodding
-            if abs(head_angles[0]) > self.NOD_THRESHOLD:
-                self.nod_counter += 1
-                if self.nod_counter >= 10:
-                    drowsy_indicators.append("HEAD_NOD")
-                    status_text.append(f"📉 Head nodding! Angle: {head_angles[0]:.1f}°")
-            else:
-                self.nod_counter = 0
-                status_text.append(f"📏 Head pose - Pitch: {head_angles[0]:.1f}°")
-            
-            # Generate alerts
-            current_time = time.time()
-            if drowsy_indicators and (current_time - self.last_alert_time) > self.alert_cooldown:
-                self.drowsy_alert = True
-                self.last_alert_time = current_time
-                
-                # Determine alert type and severity
-                if "EYES_CLOSED" in drowsy_indicators:
-                    severity = "high" if len(drowsy_indicators) > 1 else "medium"
-                    alert_message = self.generate_voice_alert("drowsy", severity)
-                elif "YAWNING" in drowsy_indicators:
-                    alert_message = self.generate_voice_alert("yawn", "medium")
-                elif "HEAD_NOD" in drowsy_indicators:
-                    alert_message = self.generate_voice_alert("nod", "medium")
-                
-                # Visual alert on frame
-                cv2.putText(frame, "⚠️ DROWSINESS ALERT! ⚠️", (50, 50), 
-                           cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3)
-            
-            # Draw landmark points
-            for (x, y) in landmarks:
-                cv2.circle(frame, (x, y), 1, (255, 255, 255), -1)
-            
-            # Add metrics overlay
-            cv2.putText(frame, f"EAR: {ear:.3f}", (10, frame.shape[0] - 80), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-            cv2.putText(frame, f"MAR: {mar:.3f}", (10, frame.shape[0] - 60), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-            cv2.putText(frame, f"Head: {head_angles[0]:.1f}°", (10, frame.shape[0] - 40), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-            
-        return frame, status_text, alert_message
+    if missing:
+        print("📦 Optional features (install for enhanced functionality):")
+        for item in missing:
+            print(f"   {item}")
 
-def create_gradio_interface():
-    """Create Gradio interface for the drowsiness detection system"""
+def main():
+    """Main entry point"""
+    print("🚗 Starting AI Driver Drowsiness Detection System...")
+    print("🔧 Using OpenCV-based detection (no external model downloads required)")
     
-    # Global detector instance
-    detector = None
+    if not check_opencv_installation():
+        sys.exit(1)
     
-    def initialize_system(gemini_key):
-        """Initialize the drowsiness detection system"""
-        global detector
-        try:
-            detector = DrowsinessDetector(gemini_key if gemini_key.strip() else None)
-            return "✅ System initialized successfully!", "System ready for detection."
-        except Exception as e:
-            return f"❌ Error initializing system: {str(e)}", "System initialization failed."
+    check_optional_dependencies()
     
-    def process_video_frame(frame, gemini_key):
-        """Process a single video frame"""
-        global detector
-        
-        if detector is None:
-            detector = DrowsinessDetector(gemini_key if gemini_key.strip() else None)
-        
-        try:
-            processed_frame, status_list, alert_msg = detector.detect_drowsiness(frame)
-            
-            # Format status text
-            status_text = "\n".join(status_list) if status_list else "Processing..."
-            
-            # Get recent logs
-            log_text = "\n".join(list(detector.status_log)[-10:]) if detector.status_log else "No logs yet."
-            
-            return processed_frame, status_text, alert_msg, log_text
-            
-        except Exception as e:
-            error_msg = f"Error processing frame: {str(e)}"
-            return frame, error_msg, "", error_msg
+    print("\n🚀 All core requirements satisfied!")
     
-    # Create the Gradio interface
-    with gr.Blocks(title="Driver Drowsiness Detection System", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 🚗 Real-time Driver Drowsiness Detection System
-        
-        This system uses computer vision and AI to detect driver drowsiness through:
-        - **Eye Aspect Ratio (EAR)** - Detects closed/droopy eyes
-        - **Mouth Aspect Ratio (MAR)** - Detects yawning
-        - **Head Pose Estimation** - Detects head nodding
-        - **AI Voice Alerts** - Uses Gemini AI for personalized wake-up messages
-        
-        ### 📋 Setup Instructions:
-        1. Download `shape_predictor_68_face_landmarks.dat` from [dlib models](http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2)
-        2. Place it in the same directory as this script
-        3. (Optional) Enter your Gemini API key for AI-powered voice alerts
-        4. Start your webcam and begin monitoring!
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                # Gemini API key input
-                gemini_key_input = os.getenv('GEMINI_API_KEY')
-                
-                
-                # Initialize button
-                init_btn = gr.Button("🚀 Initialize System", variant="primary")
-                init_status = gr.Textbox(label="Initialization Status", interactive=False)
-                
-            with gr.Column(scale=1):
-                # System info
-                gr.Markdown("""
-                ### 📊 Detection Thresholds:
-                - **EAR Threshold**: 0.25
-                - **Yawn Threshold**: 0.6  
-                - **Head Nod**: 15° deviation
-                - **Alert Cooldown**: 10 seconds
-                """)
+    # Create and launch interface
+    try:
+        interface_manager = GradioWebRTCInterface()
+        demo = interface_manager.create_interface()
         
-        with gr.Row():
-            with gr.Column(scale=2):
-                # Video input/output
-                video_input = gr.Video(
-                    sources=["webcam"], 
-                    label="📹 Camera Feed",
-                    streaming=True
-                )
-                
-            with gr.Column(scale=1):
-                # Status displays
-                current_status = gr.Textbox(
-                    label="📈 Current Status", 
-                    lines=6,
-                    interactive=False
-                )
-                
-                alert_display = gr.Textbox(
-                    label="🔊 Latest Alert", 
-                    interactive=False,
-                    placeholder="No alerts yet..."
-                )
-                
-                system_logs = gr.Textbox(
-                    label="📝 System Logs", 
-                    lines=8,
-                    interactive=False,
-                    placeholder="System logs will appear here..."
-                )
+        print("🌐 Launching Gradio interface...")
+        print("📱 The interface will be available in your browser")
+        print("🔗 A public link will be generated for sharing")
         
-        # Event handlers
-        init_btn.click(
-            fn=initialize_system,
-            inputs=[gemini_key_input],
-            outputs=[init_status, alert_display]
-        )
-        
-        video_input.stream(
-            fn=process_video_frame,
-            inputs=[video_input, gemini_key_input],
-            outputs=[video_input, current_status, alert_display, system_logs],
-            stream_every=0.1,  # Process every 100ms
-            show_progress=False
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            show_error=True,
+            enable_queue=True,
+            max_threads=10,
+            favicon_path=None
         )
         
-        # Instructions
-        gr.Markdown("""
-        ### 🔧 Troubleshooting:
-        - **No face detected**: Ensure good lighting and face is visible to camera
-        - **Poor detection**: Adjust camera angle and distance (arm's length recommended)
-        - **No alerts**: Check if Gemini API key is valid (optional feature)
-        - **High CPU usage**: Reduce video resolution or increase stream interval
-        
-        ### ⚠️ Safety Notice:
-        This system is for demonstration purposes. Always prioritize real-world driving safety measures.
-        Pull over safely if you feel drowsy while driving.
-        """)
-    
-    return demo
+    except Exception as e:
+        print(f"❌ Error launching interface: {e}")
+        print("💡 Try running: pip install --upgrade gradio")
+        sys.exit(1)
 
-# Main execution
 if __name__ == "__main__":
-    # Check for required files
-    if not os.path.exists('shape_predictor_68_face_landmarks.dat'):
-        print("❌ Missing required file: shape_predictor_68_face_landmarks.dat")
-        print("📥 Please download from: http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2")
-        print("📁 Extract and place in the same directory as this script")
-    else:
-        print("✅ All required files found!")
-        
-        # Create and launch the interface
-        demo = create_gradio_interface()
-        demo.launch(
-            share=True,
-            server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True
-        )
+    main()
+
+# requirements.txt
+"""
+opencv-python>=4.5.0
+gradio>=4.0.0
+numpy>=1.21.0
+scipy>=1.7.0
+google-generativeai>=0.3.0
+mediapipe>=0.10.0  # Optional for enhanced detection
+"""
+
+# README.md
+"""
+# 🚗 AI Driver Drowsiness Detection System
+
+A real-time drowsiness detection system using computer vision and AI-powered alerts.
+
+## ✨ Features
+
+- **No External Downloads**: Uses OpenCV's built-in face detection models
+- **Real-time Processing**: WebRTC streaming for low latency
+- **Multi-modal Detection**: Eyes, mouth, and head pose analysis
+- **AI Voice Alerts**: Contextual messages powered by Gemini AI
+- **Adaptive System**: Graceful fallback without external dependencies
+- **Easy Setup**: Simple pip install, no model downloads required
+
+## 🚀 Quick Start
+
+1. **Install dependencies:**
+   ```bash
+   pip install opencv-python gradio numpy scipy google-generativeai
+   
+   # Optional for enhanced detection:
+   pip install mediapipe
+   ```
+
+2. **Run the system:**
+   ```bash
+   python main.py
+   ```
+
+3. **Open browser** and navigate to the provided URL
+
+4. **Optional**: Enter Gemini API key for AI-powered voice alerts
+
+## 🔧 How It Works
+
+### Detection Methods
+- **Primary**: MediaPipe Face Mesh (if available) for precise landmarks
+- **Fallback**: OpenCV Haar Cascades for basic face/eye/mouth detection
+- **Hybrid Approach**: Automatically selects best available method
+
+### Drowsiness Indicators
+- **Eye Aspect Ratio (EAR)**: Detects eye closure patterns
+- **Mouth Aspect Ratio (MAR)**: Identifies yawning behavior
+- **Head Pose**: Tracks head nodding and position
+
+### Alert System
+- **AI-Generated**: Contextual messages via Gemini
+- **Audio Alerts**: Attention-grabbing beep patterns
+- **Visual Feedback**: Real-time overlay on video stream
+- **Smart Cooldown**: Prevents alert spam
+
+## ⚙️ Configuration
+
+### Detection Thresholds
+- **EAR Threshold**: 0.20 (adjustable for sensitivity)
+- **MAR Threshold**: 0.8 (calibrated for yawn detection)
+- **Head Nod**: 20° deviation threshold
+- **Alert Cooldown**: 8 seconds between alerts
+
+### Performance Optimization
+- **Stream Rate**: 10 FPS processing (configurable)
+- **Queue Management**: Prevents frame backlog
+- **Multi-threading**: Separate processing pipeline
+- **Graceful Degradation**: Maintains functionality with limited resources
+
+## 🛡️ Safety Notice
+
+**This system is for demonstration and research purposes only.**
+
+- Not a substitute for responsible driving practices
+- Always pull over safely if feeling drowsy
+- Use as supplementary tool alongside other safety measures
+- Ensure proper camera setup and lighting
+
+## 📋 System Requirements
+
+- **Python**: 3.7+
+- **Camera**: Webcam or built-in camera
+- **OS**: Windows, macOS, Linux
+- **RAM**: 4GB+ recommended
+- **CPU**: Multi-core recommended for real-time processing
+
+## 🔍 Troubleshooting
+
+- **No face detected**: Check lighting and camera position
+- **Poor detection**: Ensure face is clearly visible and well-lit
+- **High CPU usage**: Reduce stream rate or video resolution
+- **Audio issues**: Check browser permissions and audio settings
+
+## 📝 License
+
+MIT License - See LICENSE file for details
+"""

facial_detection.py

@@ -0,0 +1,415 @@
+# facial_detection.py
+import cv2
+import numpy as np
+from scipy.spatial import distance as dist
+from collections import deque
+import time
+from datetime import datetime
+
+class OpenCVFaceDetector:
+    """Face detection and landmark estimation using OpenCV"""
+    
+    def __init__(self):
+        # Load OpenCV's pre-trained face detection models
+        self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        self.eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')
+        self.mouth_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_smile.xml')
+        
+        # Try to load MediaPipe for better landmark detection (fallback if not available)
+        self.use_mediapipe = False
+        try:
+            import mediapipe as mp
+            self.mp_face_mesh = mp.solutions.face_mesh
+            self.mp_drawing = mp.solutions.drawing_utils
+            self.face_mesh = self.mp_face_mesh.FaceMesh(
+                static_image_mode=False,
+                max_num_faces=1,
+                refine_landmarks=True,
+                min_detection_confidence=0.5,
+                min_tracking_confidence=0.5
+            )
+            self.use_mediapipe = True
+            print("✅ Using MediaPipe for enhanced landmark detection")
+        except ImportError:
+            print("⚠️ MediaPipe not available, using OpenCV cascade classifiers")
+            
+        # Define landmark indices for MediaPipe (68-point equivalent)
+        self.LEFT_EYE_INDICES = [33, 7, 163, 144, 145, 153, 154, 155, 133, 173, 157, 158, 159, 160, 161, 246]
+        self.RIGHT_EYE_INDICES = [362, 382, 381, 380, 374, 373, 390, 249, 263, 466, 388, 387, 386, 385, 384, 398]
+        self.MOUTH_INDICES = [78, 95, 88, 178, 87, 14, 317, 402, 318, 324, 308, 415, 310, 311, 312, 13, 82, 81, 80, 62]
+        
+    def detect_faces_opencv(self, frame):
+        """Detect faces using OpenCV Haar cascades"""
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = self.face_cascade.detectMultiScale(gray, 1.3, 5)
+        return faces, gray
+    
+    def estimate_landmarks_opencv(self, frame, face_rect):
+        """Estimate key facial landmarks using OpenCV cascades"""
+        x, y, w, h = face_rect
+        roi_gray = frame[y:y+h, x:x+w]
+        roi_color = frame[y:y+h, x:x+w]
+        
+        # Detect eyes
+        eyes = self.eye_cascade.detectMultiScale(roi_gray, 1.1, 3)
+        # Detect mouth/smile
+        mouths = self.mouth_cascade.detectMultiScale(roi_gray, 1.1, 3)
+        
+        landmarks = {}
+        
+        # Process eyes
+        if len(eyes) >= 2:
+            # Sort eyes by x-coordinate (left to right)
+            eyes = sorted(eyes, key=lambda e: e[0])
+            landmarks['left_eye'] = (x + eyes[0][0] + eyes[0][2]//2, y + eyes[0][1] + eyes[0][3]//2)
+            landmarks['right_eye'] = (x + eyes[1][0] + eyes[1][2]//2, y + eyes[1][1] + eyes[1][3]//2)
+            
+            # Estimate eye corners based on eye rectangles
+            landmarks['left_eye_corners'] = [
+                (x + eyes[0][0], y + eyes[0][1] + eyes[0][3]//2),  # left corner
+                (x + eyes[0][0] + eyes[0][2], y + eyes[0][1] + eyes[0][3]//2),  # right corner
+                (x + eyes[0][0] + eyes[0][2]//2, y + eyes[0][1]),  # top
+                (x + eyes[0][0] + eyes[0][2]//2, y + eyes[0][1] + eyes[0][3])  # bottom
+            ]
+            landmarks['right_eye_corners'] = [
+                (x + eyes[1][0], y + eyes[1][1] + eyes[1][3]//2),
+                (x + eyes[1][0] + eyes[1][2], y + eyes[1][1] + eyes[1][3]//2),
+                (x + eyes[1][0] + eyes[1][2]//2, y + eyes[1][1]),
+                (x + eyes[1][0] + eyes[1][2]//2, y + eyes[1][1] + eyes[1][3])
+            ]
+        
+        # Process mouth
+        if len(mouths) > 0:
+            mouth = mouths[0]  # Take the first detected mouth
+            landmarks['mouth_center'] = (x + mouth[0] + mouth[2]//2, y + mouth[1] + mouth[3]//2)
+            landmarks['mouth_corners'] = [
+                (x + mouth[0], y + mouth[1] + mouth[3]//2),  # left corner
+                (x + mouth[0] + mouth[2], y + mouth[1] + mouth[3]//2),  # right corner
+                (x + mouth[0] + mouth[2]//2, y + mouth[1]),  # top
+                (x + mouth[0] + mouth[2]//2, y + mouth[1] + mouth[3])  # bottom
+            ]
+        
+        # Estimate nose tip (center of face, slightly above mouth)
+        landmarks['nose_tip'] = (x + w//2, y + int(h*0.6))
+        
+        # Estimate chin (bottom center of face)
+        landmarks['chin'] = (x + w//2, y + h)
+        
+        return landmarks
+    
+    def detect_landmarks_mediapipe(self, frame):
+        """Detect landmarks using MediaPipe"""
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = self.face_mesh.process(rgb_frame)
+        
+        landmarks_dict = {}
+        
+        if results.multi_face_landmarks:
+            face_landmarks = results.multi_face_landmarks[0]
+            h, w, _ = frame.shape
+            
+            # Extract eye landmarks
+            left_eye_points = []
+            right_eye_points = []
+            mouth_points = []
+            
+            for i in self.LEFT_EYE_INDICES[:6]:  # Take first 6 points for eye shape
+                point = face_landmarks.landmark[i]
+                left_eye_points.append((int(point.x * w), int(point.y * h)))
+            
+            for i in self.RIGHT_EYE_INDICES[:6]:
+                point = face_landmarks.landmark[i]
+                right_eye_points.append((int(point.x * w), int(point.y * h)))
+            
+            for i in self.MOUTH_INDICES[:8]:  # Take key mouth points
+                point = face_landmarks.landmark[i]
+                mouth_points.append((int(point.x * w), int(point.y * h)))
+            
+            landmarks_dict['left_eye_corners'] = left_eye_points
+            landmarks_dict['right_eye_corners'] = right_eye_points
+            landmarks_dict['mouth_corners'] = mouth_points
+            
+            # Key points
+            nose_tip = face_landmarks.landmark[1]  # Nose tip
+            chin = face_landmarks.landmark[175]    # Chin
+            
+            landmarks_dict['nose_tip'] = (int(nose_tip.x * w), int(nose_tip.y * h))
+            landmarks_dict['chin'] = (int(chin.x * w), int(chin.y * h))
+            
+            # Calculate face bounding box
+            x_coords = [int(lm.x * w) for lm in face_landmarks.landmark]
+            y_coords = [int(lm.y * h) for lm in face_landmarks.landmark]
+            
+            face_rect = (min(x_coords), min(y_coords), 
+                        max(x_coords) - min(x_coords), 
+                        max(y_coords) - min(y_coords))
+            
+            return face_rect, landmarks_dict
+        
+        return None, {}
+    
+    def detect_landmarks(self, frame):
+        """Main method to detect face and landmarks"""
+        if self.use_mediapipe:
+            face_rect, landmarks = self.detect_landmarks_mediapipe(frame)
+            if face_rect is not None:
+                return [face_rect], [landmarks]
+        
+        # Fallback to OpenCV
+        faces, gray = self.detect_faces_opencv(frame)
+        landmarks_list = []
+        face_rects = []
+        
+        for face in faces:
+            landmarks = self.estimate_landmarks_opencv(gray, face)
+            if landmarks:
+                landmarks_list.append(landmarks)
+                face_rects.append(face)
+        
+        return face_rects, landmarks_list
+
+class MetricsCalculator:
+    """Calculate drowsiness metrics from facial landmarks"""
+    
+    @staticmethod
+    def calculate_ear_from_points(eye_points):
+        """Calculate Eye Aspect Ratio from eye corner points"""
+        if len(eye_points) < 4:
+            return 0.3  # Default value
+        
+        # For 4-point eye estimation: [left, right, top, bottom]
+        if len(eye_points) == 4:
+            left, right, top, bottom = eye_points
+            # Vertical distances
+            vertical_dist = dist.euclidean(top, bottom)
+            # Horizontal distance
+            horizontal_dist = dist.euclidean(left, right)
+            
+            if horizontal_dist == 0:
+                return 0.3
+            
+            ear = vertical_dist / horizontal_dist
+            return ear
+        
+        # For 6-point eye estimation (MediaPipe style)
+        elif len(eye_points) >= 6:
+            # Calculate vertical distances
+            v1 = dist.euclidean(eye_points[1], eye_points[5])
+            v2 = dist.euclidean(eye_points[2], eye_points[4])
+            # Horizontal distance
+            h = dist.euclidean(eye_points[0], eye_points[3])
+            
+            if h == 0:
+                return 0.3
+            
+            ear = (v1 + v2) / (2.0 * h)
+            return ear
+        
+        return 0.3
+    
+    @staticmethod
+    def calculate_mar_from_points(mouth_points):
+        """Calculate Mouth Aspect Ratio from mouth points"""
+        if len(mouth_points) < 4:
+            return 0.3  # Default value
+        
+        if len(mouth_points) == 4:
+            # [left, right, top, bottom]
+            left, right, top, bottom = mouth_points
+            vertical_dist = dist.euclidean(top, bottom)
+            horizontal_dist = dist.euclidean(left, right)
+            
+            if horizontal_dist == 0:
+                return 0.3
+            
+            mar = vertical_dist / horizontal_dist
+            return mar
+        
+        elif len(mouth_points) >= 8:
+            # More sophisticated mouth analysis
+            # Calculate multiple vertical distances
+            v1 = dist.euclidean(mouth_points[1], mouth_points[7])
+            v2 = dist.euclidean(mouth_points[2], mouth_points[6])
+            v3 = dist.euclidean(mouth_points[3], mouth_points[5])
+            
+            # Horizontal distance
+            h = dist.euclidean(mouth_points[0], mouth_points[4])
+            
+            if h == 0:
+                return 0.3
+            
+            mar = (v1 + v2 + v3) / (3.0 * h)
+            return mar
+        
+        return 0.3
+    
+    @staticmethod
+    def estimate_head_pose_simple(nose_tip, chin, frame_center):
+        """Simple head pose estimation using nose and chin"""
+        if nose_tip is None or chin is None:
+            return np.array([0, 0, 0])
+        
+        # Calculate head tilt based on nose-chin line deviation from vertical
+        nose_chin_vector = np.array([chin[0] - nose_tip[0], chin[1] - nose_tip[1]])
+        vertical_vector = np.array([0, 1])
+        
+        # Calculate angle from vertical
+        dot_product = np.dot(nose_chin_vector, vertical_vector)
+        norms = np.linalg.norm(nose_chin_vector) * np.linalg.norm(vertical_vector)
+        
+        if norms == 0:
+            return np.array([0, 0, 0])
+        
+        cos_angle = dot_product / norms
+        angle = np.arccos(np.clip(cos_angle, -1, 1)) * 180 / np.pi
+        
+        # Determine direction of tilt
+        if nose_chin_vector[0] < 0:
+            angle = -angle
+        
+        # Simple pitch estimation based on nose position relative to frame center
+        pitch = (nose_tip[1] - frame_center[1]) / frame_center[1] * 30  # Scale to degrees
+        
+        return np.array([pitch, 0, angle])  # [pitch, yaw, roll]
+
+class DrowsinessAnalyzer:
+    """Analyze drowsiness based on facial metrics"""
+    
+    def __init__(self):
+        # Thresholds
+        self.EAR_THRESHOLD = 0.20  # Adjusted for OpenCV detection
+        self.EAR_CONSECUTIVE_FRAMES = 15
+        self.YAWN_THRESHOLD = 0.8  # Adjusted for mouth detection
+        self.YAWN_CONSECUTIVE_FRAMES = 10
+        self.NOD_THRESHOLD = 20
+        
+        # Counters
+        self.ear_counter = 0
+        self.yawn_counter = 0
+        self.nod_counter = 0
+        
+        # History tracking
+        self.ear_history = deque(maxlen=30)
+        self.yawn_history = deque(maxlen=30)
+        self.head_pose_history = deque(maxlen=30)
+        
+    def analyze_drowsiness(self, ear, mar, head_angles):
+        """Analyze current metrics and return drowsiness indicators"""
+        drowsiness_indicators = []
+        
+        # Update history
+        self.ear_history.append(ear)
+        self.yawn_history.append(mar)
+        self.head_pose_history.append(head_angles[0])
+        
+        # Check EAR (eyes closed detection)
+        if ear < self.EAR_THRESHOLD:
+            self.ear_counter += 1
+            if self.ear_counter >= self.EAR_CONSECUTIVE_FRAMES:
+                drowsiness_indicators.append("EYES_CLOSED")
+        else:
+            self.ear_counter = 0
+        
+        # Check yawning
+        if mar > self.YAWN_THRESHOLD:
+            self.yawn_counter += 1
+            if self.yawn_counter >= self.YAWN_CONSECUTIVE_FRAMES:
+                drowsiness_indicators.append("YAWNING")
+        else:
+            self.yawn_counter = 0
+        
+        # Check head nodding
+        if abs(head_angles[0]) > self.NOD_THRESHOLD:
+            self.nod_counter += 1
+            if self.nod_counter >= 8:
+                drowsiness_indicators.append("HEAD_NOD")
+        else:
+            self.nod_counter = 0
+        
+        return drowsiness_indicators
+    
+    def get_severity_level(self, indicators):
+        """Determine severity based on indicators"""
+        if len(indicators) >= 2:
+            return "critical"
+        elif "EYES_CLOSED" in indicators:
+            return "high"
+        elif indicators:
+            return "medium"
+        else:
+            return "normal"
+
+class AlertManager:
+    """Manage alert generation and timing"""
+    
+    def __init__(self, cooldown_seconds=8):
+        self.last_alert_time = 0
+        self.cooldown_seconds = cooldown_seconds
+        
+    def should_trigger_alert(self, indicators):
+        """Check if alert should be triggered"""
+        current_time = time.time()
+        if indicators and (current_time - self.last_alert_time) > self.cooldown_seconds:
+            self.last_alert_time = current_time
+            return True
+        return False
+
+class VisualizationRenderer:
+    """Handle visual rendering of detection results"""
+    
+    @staticmethod
+    def draw_landmarks_and_contours(frame, landmarks, face_rect):
+        """Draw facial landmarks and detection areas"""
+        x, y, w, h = face_rect
+        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+        
+        # Draw eye areas
+        if 'left_eye_corners' in landmarks:
+            points = np.array(landmarks['left_eye_corners'], np.int32)
+            cv2.polylines(frame, [points], True, (0, 255, 0), 2)
+        
+        if 'right_eye_corners' in landmarks:
+            points = np.array(landmarks['right_eye_corners'], np.int32)
+            cv2.polylines(frame, [points], True, (0, 255, 0), 2)
+        
+        # Draw mouth area
+        if 'mouth_corners' in landmarks:
+            points = np.array(landmarks['mouth_corners'], np.int32)
+            cv2.polylines(frame, [points], True, (0, 255, 255), 2)
+        
+        # Draw key points
+        key_points = ['nose_tip', 'chin']
+        for point_name in key_points:
+            if point_name in landmarks:
+                cv2.circle(frame, landmarks[point_name], 3, (255, 0, 0), -1)
+    
+    @staticmethod
+    def draw_metrics_overlay(frame, ear, mar, head_angle, indicators):
+        """Draw metrics and alerts on frame"""
+        # Metrics text
+        cv2.putText(frame, f"EAR: {ear:.3f}", (10, frame.shape[0] - 80), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+        cv2.putText(frame, f"MAR: {mar:.3f}", (10, frame.shape[0] - 60), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+        cv2.putText(frame, f"Head: {head_angle:.1f}°", (10, frame.shape[0] - 40), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+        
+        # Alert overlay
+        if indicators:
+            cv2.putText(frame, "⚠️ DROWSINESS ALERT! ⚠️", (50, 50), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3)
+
+class StatusLogger:
+    """Handle logging and status tracking"""
+    
+    def __init__(self, max_logs=100):
+        self.status_log = deque(maxlen=max_logs)
+        
+    def log(self, message):
+        """Add timestamped log entry"""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        self.status_log.append(f"[{timestamp}] {message}")
+        
+    def get_recent_logs(self, count=10):
+        """Get recent log entries"""
+        return list(self.status_log)[-count:]

gradio_interface.py

@@ -0,0 +1,277 @@
+import os
+import gradio as gr
+import queue
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from ai_alert_generator import AIAlertGenerator, DrowsinessDetectionSystem
+
+class GradioWebRTCInterface:
+    """Enhanced Gradio interface with WebRTC support"""
+    
+    def __init__(self):
+        self.detection_system = None
+        self.ai_alert_generator = None
+        self.processing = False
+        
+    def initialize_system(self, gemini_key):
+        """Initialize the detection system"""
+        try:
+            self.detection_system = DrowsinessDetectionSystem()
+            self.ai_alert_generator = AIAlertGenerator(gemini_key if gemini_key.strip() else None)
+            
+            return "✅ System initialized successfully!", "🚀 Ready for detection"
+        except Exception as e:
+            return f"❌ Error: {str(e)}", "❌ Initialization failed"
+    
+    def process_video_stream(self, frame, gemini_key):
+        """Process video stream"""
+        if self.detection_system is None:
+            self.detection_system = DrowsinessDetectionSystem()
+            self.ai_alert_generator = AIAlertGenerator(gemini_key if gemini_key.strip() else None)
+        
+        try:
+            # Process frame
+            processed_frame, status_list, should_alert, metrics = self.detection_system.process_frame(frame)
+            
+            # Generate alert if needed
+            alert_text = ""
+            alert_audio = None
+            
+            if should_alert and metrics.get('indicators'):
+                alert_text = self.ai_alert_generator.generate_alert_text(
+                    metrics['indicators'], 
+                    metrics.get('severity', 'medium')
+                )
+                
+                # Create audio alert
+                try:
+                    audio_file, _ = self.ai_alert_generator.create_audio_alert(alert_text)
+                    alert_audio = audio_file
+                except Exception as e:
+                    print(f"Audio generation error: {e}")
+            
+            # Format status
+            status_text = "\n".join(status_list)
+            
+            # Get logs
+            logs = self.detection_system.get_logs()
+            
+            return processed_frame, status_text, alert_text, alert_audio, logs
+            
+        except Exception as e:
+            error_msg = f"Processing error: {str(e)}"
+            return frame, error_msg, "", None, error_msg
+    
+    def create_interface(self):
+        """Create the Gradio interface with WebRTC support"""
+        with gr.Blocks(
+            title="🚗 AI Driver Drowsiness Detection System",
+            theme=gr.themes.Soft(),
+            css="""
+            .alert-box { 
+                background-color: #ffebee; 
+                border: 2px solid #f44336; 
+                border-radius: 8px; 
+                padding: 10px; 
+            }
+            .status-box { 
+                background-color: #e8f5e8; 
+                border: 2px solid #4caf50; 
+                border-radius: 8px; 
+                padding: 10px; 
+            }
+            .metric-display { 
+                font-family: 'Courier New', monospace; 
+                font-size: 14px; 
+            }
+            .header-text {
+                text-align: center;
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                color: white;
+                padding: 20px;
+                border-radius: 10px;
+                margin-bottom: 20px;
+            }
+            """
+        ) as interface:
+            
+            gr.HTML("""
+            <div class="header-text">
+                <h1>🚗 AI-Powered Driver Drowsiness Detection System</h1>
+                <p><strong>Real-time monitoring with OpenCV, Computer Vision & AI Alerts</strong></p>
+                <p><em>No external model downloads required - Uses built-in OpenCV detection</em></p>
+            </div>
+            """)
+            
+            with gr.Tab("🎥 Live Detection"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        # WebRTC video input
+                        video_input = gr.Video(
+                            label="📹 Camera Feed (WebRTC Streaming)",
+                            sources=["webcam"],
+                            streaming=True,
+                            mirror_webcam=False,
+                            height=480
+                        )
+                        
+                        # System controls
+                        with gr.Row():
+                            gemini_key = os.getenv("GEMINI_API_KEY")
+                            # init_btn = gr.Button("🚀 Initialize", variant="primary", scale=1)
+                    
+                    with gr.Column(scale=1):
+                        # System status
+                        init_status = gr.Textbox(
+                            label="🔧 System Status",
+                            interactive=False,
+                            lines=2,
+                            elem_classes=["status-box"]
+                        )
+                        
+                        # Detection metrics
+                        current_status = gr.Textbox(
+                            label="📊 Detection Metrics",
+                            interactive=False,
+                            lines=8,
+                            elem_classes=["metric-display"]
+                        )
+                        
+                        # Alert display
+                        alert_text_display = gr.Textbox(
+                            label="🚨 Active Alert",
+                            interactive=False,
+                            lines=3,
+                            elem_classes=["alert-box"]
+                        )
+                        
+                        # Audio alert output
+                        alert_audio = gr.Audio(
+                            label="🔊 Alert Sound",
+                            autoplay=True,
+                            visible=True
+                        )
+                
+                # System logs panel
+                with gr.Row():
+                    system_logs = gr.Textbox(
+                        label="📝 System Activity Log",
+                        lines=6,
+                        interactive=False,
+                        elem_classes=["metric-display"]
+                    )
+            
+            with gr.Tab("⚙️ System Configuration"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("""
+                        ### 🔧 Detection Parameters
+                        
+                        **Current OpenCV-based thresholds:**
+                        - **Eye Aspect Ratio (EAR)**: < 0.20 for 15+ frames
+                        - **Mouth Aspect Ratio (MAR)**: > 0.8 for 10+ frames  
+                        - **Head Nod Angle**: > 20° deviation for 8+ frames
+                        - **Alert Cooldown**: 8 seconds between alerts
+                        
+                        ### 🎯 Detection Methods
+                        - **Primary**: MediaPipe Face Mesh (if available)
+                        - **Fallback**: OpenCV Haar Cascades
+                        - **No external downloads**: Uses built-in OpenCV models
+                        """)
+                    
+                    with gr.Column():
+                        gr.Markdown("""
+                        ### 📋 Easy Setup
+                        
+                        **Install dependencies:**
+                        ```bash
+                        pip install opencv-python gradio numpy scipy google-generativeai
+                        
+                        # Optional for better detection:
+                        pip install mediapipe
+                        ```
+                        
+                        **No model downloads required!**
+                        - Uses OpenCV's built-in face detection
+                        - MediaPipe auto-detects if available
+                        - Gemini API key is optional for AI alerts
+                        """)
+                
+                gr.Markdown("""
+                ### 🚀 Advanced Features
+                - **Real-time WebRTC Processing**: Low latency video streaming
+                - **Multi-modal Detection**: Eyes, mouth, and head pose analysis
+                - **AI-Powered Alerts**: Contextual voice messages via Gemini
+                - **Adaptive Fallback**: Graceful degradation without external models
+                - **Visual Feedback**: Live metrics overlay on video
+                - **Comprehensive Logging**: Detailed activity tracking
+                """)
+            
+            with gr.Tab("📊 Detection Info"):
+                gr.Markdown("""
+                ### 👁️ Eye Aspect Ratio (EAR)
+                
+                **How it works:**
+                - Calculates ratio of eye height to width
+                - Lower values indicate closed/closing eyes
+                - Triggers alert when consistently low
+                
+                **Detection method:**
+                - **MediaPipe**: Uses precise eye landmarks
+                - **OpenCV**: Estimates from eye rectangles
+                
+                ### 👄 Mouth Aspect Ratio (MAR)
+                
+                **Yawn detection:**
+                - Measures mouth opening relative to width
+                - Higher values indicate yawning
+                - Accounts for talking vs. yawning patterns
+                
+                ### 📐 Head Pose Estimation
+                
+                **Nodding detection:**
+                - Tracks head tilt and position
+                - Detects forward head movement
+                - Uses nose-chin alignment for pose estimation
+                
+                ### 🧠 AI Alert Generation
+                
+                **Smart alerts:**
+                - Context-aware messages via Gemini
+                - Severity-based escalation
+                - Fallback to audio beeps
+                - Cooldown prevents alert spam
+                """)
+            
+            # Event handlers
+            init_btn.click(
+                fn=self.initialize_system,
+                inputs=[gemini_key],
+                outputs=[init_status, alert_text_display]
+            )
+            
+            # WebRTC stream processing
+            video_input.stream(
+                fn=self.process_video_stream,
+                inputs=[video_input, gemini_key],
+                outputs=[video_input, current_status, alert_text_display, alert_audio, system_logs],
+                stream_every=0.1,  # 10 FPS processing
+                show_progress=False
+            )
+            
+            # Safety notice
+            gr.HTML("""
+            <div style="margin-top: 20px; padding: 15px; background: linear-gradient(135deg, #ffeaa7 0%, #fab1a0 100%); border-radius: 8px; border-left: 5px solid #e17055;">
+                <h3>⚠️ Important Safety Notice</h3>
+                <p><strong>This system is for demonstration and research purposes only.</strong></p>
+                <ul style="margin: 10px 0;">
+                    <li><strong>Not a substitute</strong> for responsible driving practices</li>
+                    <li><strong>Pull over safely</strong> if you feel drowsy while driving</li>
+                    <li><strong>Ensure proper setup</strong>: good lighting, stable camera position</li>
+                    <li><strong>Use as supplementary tool</strong> alongside other safety measures</li>
+                </ul>
+                <p style="margin-top: 15px;"><em>Always prioritize real-world driving safety over technology assistance.</em></p>
+            </div>
+            """)
+        
+        return interface