Update app.py

app.py

@@ -1,4 +1,4 @@
-# app_gradio.py
+# app_webrtc.py
 import gradio as gr
 import numpy as np
 import os
@@ -6,13 +6,16 @@ import yaml
 from dotenv import load_dotenv
 import io
 from scipy.io.wavfile import read as read_wav
+from pydub import AudioSegment
+import cv2
+import time
+from gradio_webrtc import WebRTC
 
 # Correctly import from the drive_paddy package structure
-from src.detection.factory import get_detector
-from src.alerting.alert_system import get_alerter
+from drive_paddy.detection.factory import get_detector
+from drive_paddy.alerting.alert_system import get_alerter
 
 # --- Load Configuration and Environment Variables ---
-# This part is the same as our Streamlit app
 load_dotenv()
 config_path = 'config.yaml'
 with open(config_path, 'r') as f:
@@ -22,151 +25,116 @@ secrets = {
 }
 
 # --- Initialize Backend Components ---
-# We create these once and reuse them.
 detector = get_detector(config)
 alerter = get_alerter(config, secrets["gemini_api_key"])
-
 geo_settings = config.get('geometric_settings', {})
 drowsiness_levels = geo_settings.get('drowsiness_levels', {})
 SLIGHTLY_DROWSY_DEFAULT = drowsiness_levels.get('slightly_drowsy_threshold', 0.3)
 VERY_DROWSY_DEFAULT = drowsiness_levels.get('very_drowsy_threshold', 0.8)
 
+# --- Global state for audio (simpler than queues for this component) ---
+# We use a global variable to hold the audio data, which the UI will poll.
+# This is a common pattern in simple Gradio streaming apps.
+latest_audio_alert = None
 
-# --- Audio Processing for Gradio ---
-# Gradio's gr.Audio component needs a specific format: (sample_rate, numpy_array)
-def process_audio_for_gradio(audio_bytes):
-    """Converts in-memory audio bytes to a format Gradio can play."""
-    # gTTS creates MP3, so we read it as such
-    byte_io = io.BytesIO(audio_bytes)
-    # The 'read' function from scipy.io.wavfile expects a WAV file.
-    # We need to first convert the MP3 bytes from gTTS to WAV bytes.
-    # This requires pydub.
-    try:
-        from pydub import AudioSegment
-        audio = AudioSegment.from_mp3(byte_io)
-        wav_byte_io = io.BytesIO()
-        audio.export(wav_byte_io, format="wav")
-        wav_byte_io.seek(0)
-        
-        sample_rate, data = read_wav(wav_byte_io)
-        return (sample_rate, data)
-    except Exception as e:
-        print(f"Could not process audio for Gradio: {e}")
-        return None
-
-# --- Main Processing Function for Gradio ---
-# This function is the core of the app. It takes a webcam frame and returns
-# updates for all the output components.
-def process_live_frame(frame):
+# --- Main Processing Function ---
+def process_stream(frame: np.ndarray, sensitivity_threshold: float) -> np.ndarray:
     """
-    Takes a single frame from the Gradio webcam input, processes it,
-    and returns the processed frame, status text, and any audio alerts.
+    This is the core function. It takes a frame and returns the processed frame.
+    All logic, including status drawing and alert triggering, happens here.
     """
+    global latest_audio_alert
+    
     if frame is None:
-        # Return default values if frame is None
-        blank_image = np.zeros((480, 640, 3), dtype=np.uint8)
-        return blank_image, "Status: Inactive", None
+        return np.zeros((480, 640, 3), dtype=np.uint8)
 
-    # Process the frame using our existing detector
+    # Process the frame using our existing detector.
+    # The detector already draws landmarks and status overlays.
     processed_frame, indicators, _ = detector.process_frame(frame)
     drowsiness_level = indicators.get("drowsiness_level", "Awake")
-    lighting = indicators.get("lighting", "Good")
-    score = indicators.get("details", {}).get("Score", 0)
-
-    # Build the status text
-    # Determine drowsiness level based on the UI slider's value
-    drowsiness_level = "Awake"
-    if score >= VERY_DROWSY_DEFAULT:  # Use a fixed upper threshold
-        drowsiness_level = "Very Drowsy"
-    elif score >= sensitivity_threshold: # Use the slider for slight drowsiness
-        drowsiness_level = "Slightly Drowsy"
-
-    # Build the status text with explicit details
-    status_text = f"Lighting: {lighting}\n"
-    if lighting == "Low":
-        status_text += "Detection paused due to low light."
-    else:
-        status_text += f"Status: {drowsiness_level}\nScore: {score:.2f} (Threshold: {sensitivity_threshold:.2f})"
-        # Explicitly show what is being detected
-        if score > 0:
-            if indicators.get('eye_closure'): status_text += "\n- Eyes Closed Detected"
-            if indicators.get('yawning'): status_text += "\n- Yawn Detected"
-            if indicators.get('head_nod'): status_text += "\n- Head Nod Detected"
-            if indicators.get('looking_away'): status_text += "\n- Looking Away Detected"
-
-    # Handle alerts
-    audio_output = None
+
+    # Handle audio alerts
     if drowsiness_level != "Awake":
         audio_data = alerter.trigger_alert(level=drowsiness_level)
         if audio_data:
-            audio_output = process_audio_for_gradio(audio_data)
+            # Convert audio for Gradio and store it in the global variable
+            try:
+                byte_io = io.BytesIO(audio_data)
+                audio = AudioSegment.from_mp3(byte_io)
+                wav_byte_io = io.BytesIO()
+                audio.export(wav_byte_io, format="wav")
+                wav_byte_io.seek(0)
+                sample_rate, data = read_wav(wav_byte_io)
+                latest_audio_alert = (sample_rate, data)
+            except Exception as e:
+                print(f"Audio processing error: {e}")
+                latest_audio_alert = None
     else:
         alerter.reset_alert()
 
-    # Return all the values needed to update the UI
-    return processed_frame, status_text, audio_output
-
-# --- UI Definition for the Live Detection Page ---
-def create_live_detection_page():
-    """Builds the Gradio UI components for the live detection tab."""
-    with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="blue")) as live_detection_page:
-        gr.Markdown("A live test using Gradio's webcam component.")
-        with gr.Row():
-            with gr.Column():
-                webcam_input = gr.Image(sources=["webcam"], streaming=True, label="Live Camera Feed")
-            with gr.Column():
-                processed_output = gr.Image(label="Processed Feed")
-                status_output = gr.Textbox(label="Live Status", lines=3, interactive=False)
-                # Audio player is now visible for debugging and user feedback.
-                audio_alert_output = gr.Audio(autoplay=True, visible=True, label="Alert Sound")
-    # --- Added Sensitivity Slider ---
-                sensitivity_slider = gr.Slider(
-                    minimum=0.1, 
-                    maximum=1.0, 
-                    value=SLIGHTLY_DROWSY_DEFAULT, 
-                    step=0.05, 
-                    label="Alert Sensitivity Threshold",
-                    info="Lower value = more sensitive to drowsiness signs."
-                )
-    
-        # Link the inputs (webcam and slider) to the processing function and its outputs
-        webcam_input.stream(
-            fn=process_live_frame,
-            inputs=[webcam_input, sensitivity_slider],
-            outputs=[processed_output, status_output, audio_alert_output],
-            every=0.1
-    )
-    return live_detection_page
+    return processed_frame
 
-# --- UI Definition for the Home Page ---
-def create_home_page():
-    """Builds the Gradio UI components for the home/welcome tab."""
-    with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="blue")) as home_page:
-        gr.Markdown(
+# --- Function to check for and return audio alerts ---
+def get_audio_update():
+    """
+    This function is polled by the UI to check for new audio alerts.
+    """
+    global latest_audio_alert
+    if latest_audio_alert:
+        audio_to_play = latest_audio_alert
+        latest_audio_alert = None  # Clear the alert after sending it
+        return audio_to_play
+    return None
+
+# --- Gradio UI Definition ---
+with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="blue")) as app:
+    gr.HTML(
         """
         <div align="center">
-          <img src="https://em-content.zobj.net/source/samsung/380/automobile_1f697.png" alt="Car Emoji" width="100"/>
-          <h1>Welcome to Drive Paddy!</h1>
-          <p><strong>Your Drowsiness Detection Assistant</strong></p>
+            <img src="https://em-content.zobj.net/source/samsung/380/automobile_1f697.png" alt="Car Emoji" width="100"/>
+            <h1>Drive Paddyn</h1>
         </div>
-        
-        ---
-        
-        ### How It Works
-        This application uses your webcam to monitor for signs of drowsiness in real-time. Navigate to the **Live Detection** tab to begin.
-        
-        - **Multi-Signal Analysis**: Detects eye closure, yawning, and head position.
-        - **AI-Powered Alerts**: Uses Gemini to generate dynamic audio warnings.
-        - **Live Feedback**: Provides instant visual feedback on the video stream and status panel.
         """
+    )
+
+    with gr.Row():
+        # The WebRTC component now directly shows the processed output
+        webrtc_output = WebRTC(
+            label="Live Detection Feed",
+            video_source="webcam",
+        )
+
+    with gr.Row():
+        sensitivity_slider = gr.Slider(
+            minimum=0.1, 
+            maximum=1.0, 
+            value=SLIGHTLY_DROWSY_DEFAULT, 
+            step=0.05, 
+            label="Alert Sensitivity Threshold",
+            info="Lower value = more sensitive to drowsiness signs."
         )
-    return home_page
 
-# --- Combine Pages into a Tabbed Interface ---
-app = gr.TabbedInterface(
-    [create_home_page(), create_live_detection_page()],
-    ["Home", "Live Detection"]
-)
+    # Hidden audio component for playing alerts
+    audio_player = gr.Audio(autoplay=True, visible=False)
+
+    # Connect the WebRTC stream to the processing function
+    webrtc_output.stream(
+        fn=process_stream,
+        inputs=[webrtc_output, sensitivity_slider],
+        outputs=[webrtc_output],
+        # The 'every' parameter is not needed for this component; it streams as fast as possible.
+    )
+    
+    # Use a separate loop to poll for audio updates.
+    # This is more stable than returning multiple values in a high-frequency stream.
+    app.load(
+        fn=get_audio_update,
+        inputs=None,
+        outputs=[audio_player],
+        every=1 # Check for a new audio alert every 1 second
+    )
+
 
 # --- Launch the App ---
-app.launch(debug=True)
+if __name__ == "__main__":
+    app.launch(debug=True)