Work on drive-paddy to huggingface

.env.example

@@ -0,0 +1,2 @@
+GEMINI_API_KEY=your_gemini_api_key_here
+HUGGINGFACE_API_KEY=your_huggingface_api_key_here

.gitattributes

@@ -1,35 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+models/best_model_efficientnet_b7.pth filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,21 +0,0 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -8,12 +8,24 @@ app_port: 8501
 tags:
 - streamlit
 pinned: false
-short_description: Streamlit template space
+short_description: Drive Paddy is a drowsiness detection buddy for drivers, utilizing OpenCV and a fine-tuned CNN model to monitor driver alertness.
 ---
 
-# Welcome to Streamlit!
+# Drive Paddy 🚀
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+Drive Paddy is a system designed to enhance driver safety by detecting drowsiness. It utilizes **OpenCV** for real-time computer vision tasks and a **fine-tuned Convolutional Neural Network (CNN)** model to monitor driver alertness and help prevent fatigue-related incidents.
+
+## Core Functionality
+
+*   **Drowsiness Detection:** Identifies signs of driver fatigue by analyzing visual cues from a camera feed, such as eye closure duration and head pose.
+*   **Real-time Monitoring:** Continuously processes video input to assess the driver's alertness level.
+*   **Computer Vision Engine:** Leverages OpenCV for robust facial feature detection and eye state analysis.
+*   **AI-Powered Classification:** Employs a fine-tuned CNN model for accurate determination of drowsiness.
+
+## Technology Stack
+
+*   **Computer Vision:** OpenCV
+*   **Deep Learning Model:** Fine-tuned Convolutional Neural Network (CNN)
+*   **Application Framework:** Streamlit (as indicated by project metadata `tags`)
+*   **Containerization:** Docker (as indicated by project metadata `sdk`)
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).

config.yaml

@@ -0,0 +1,49 @@
+# config.yaml
+# Main configuration file for the Drive Paddy application.
+
+# -- Detection Strategy --
+# Sets the active drowsiness detection method.
+# Options: "geometric", "cnn_model", "hybrid"
+detection_strategy: "geometric"
+
+# -- Geometric Strategy Settings --
+# Parameters for the facial landmark-based detection methods.
+geometric_settings:
+  # Eye Aspect Ratio (EAR) for blink/closure detection
+  eye_ar_thresh: 0.23
+  eye_ar_consec_frames: 15
+
+  # Mouth Aspect Ratio (MAR) for yawn detection
+  yawn_mar_thresh: 0.70
+  yawn_consec_frames: 20
+
+  # Head Pose Estimation for look-away/nod-off detection
+  head_nod_thresh: 15.0      # Max downward pitch angle (in degrees)
+  head_look_away_thresh: 20.0 # Max yaw angle (in degrees)
+  head_pose_consec_frames: 20
+
+# -- CNN Model Settings --
+cnn_model_settings:
+  model_path: "models/best_model_efficientnet_b7.pth"
+  confidence_thresh: 0.8
+
+# -- Hybrid Strategy Settings --
+# Defines weights for combining signals into a single drowsiness score.
+# The system triggers an alert if the total score exceeds 'alert_threshold'.
+hybrid_settings:
+  alert_threshold: 1.0
+  weights:
+    eye_closure: 0.45
+    yawning: 0.30
+    head_nod: 0.55
+    looking_away: 0.25
+    cnn_prediction: 0.60 # Weight for the deep learning model's output
+
+# -- Alerting System --
+alerting:
+  alert_sound_path: "assets/alert.wav"
+  alert_cooldown_seconds: 5
+
+# -- Gemini API (Optional) --
+gemini_api:
+  enabled: true

download_model.py

@@ -0,0 +1,42 @@
+# download_model.py
+import os
+from huggingface_hub import hf_hub_download
+
+# --- Configuration ---
+# Details from your Hugging Face repository screenshot.
+REPO_ID = "Testys/drowsiness-detection-model"
+FILENAME = "best_model_efficientnet_b7.pth"
+LOCAL_DIR = "models"
+
+def download_model():
+    """
+    Downloads the specified model file from Hugging Face Hub
+    and saves it to the local models/ directory.
+    """
+    print(f"Downloading model '{FILENAME}' from repository '{REPO_ID}'...")
+
+    # Ensure the local directory exists.
+    if not os.path.exists(LOCAL_DIR):
+        os.makedirs(LOCAL_DIR)
+        print(f"Created directory: {LOCAL_DIR}")
+
+    try:
+        # Download the file.
+        # local_dir_use_symlinks=False ensures the file is copied to your directory
+        # instead of just pointing to the cache.
+        model_path = hf_hub_download(
+            repo_id=REPO_ID,
+            filename=FILENAME,
+            local_dir=LOCAL_DIR,
+            local_dir_use_symlinks=False,
+            # token=True # Use token for private repos, can be omitted for public ones
+        )
+        print(f"\nModel downloaded successfully!")
+        print(f"Saved to: {model_path}")
+
+    except Exception as e:
+        print(f"\nAn error occurred during download: {e}")
+        print("Please check the repository ID, filename, and your network connection.")
+
+if __name__ == "__main__":
+    download_model()

main.py

@@ -0,0 +1,72 @@
+# drive_paddy/main.py
+import streamlit as st
+import yaml
+import os
+from dotenv import load_dotenv
+
+# --- Main Application UI ---
+st.set_page_config(
+    page_title="Drive Paddy | Home",
+    page_icon="🚗",
+    layout="wide"
+)
+
+# Load config to display current settings on the home page
+@st.cache_resource
+def load_app_config():
+    load_dotenv()
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    with open('config.yaml', 'r') as f:
+        config = yaml.safe_load(f)
+    return config, gemini_api_key
+
+config, gemini_api_key = load_app_config()
+
+# --- Initialize Session State ---
+# This ensures they are set when the app first loads.
+if "play_audio" not in st.session_state:
+    st.session_state.play_audio = None
+if "active_alerts" not in st.session_state:
+    st.session_state.active_alerts = {"status": "Awake"}
+
+
+# --- Page Content ---
+st.title("🚗 Welcome to Drive Paddy!")
+st.subheader("Your AI-Powered Drowsiness Detection Assistant")
+
+st.markdown("""
+Drive Paddy is a real-time system designed to enhance driver safety by detecting signs of drowsiness. 
+It uses your computer's webcam to analyze facial features and head movements, providing timely alerts 
+to help prevent fatigue-related accidents.
+""")
+
+st.info("Navigate to the **Live Detection** page from the sidebar on the left to start the system.")
+
+st.markdown("---")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.header("How It Works")
+    st.markdown("""
+    The system employs a sophisticated hybrid strategy to monitor for signs of fatigue:
+    - **👀 Eye Closure Detection**: Measures Eye Aspect Ratio (EAR) to detect prolonged blinks or closed eyes.
+    - **🥱 Yawn Detection**: Measures Mouth Aspect Ratio (MAR) to identify yawns.
+    - **😴 Head Pose Analysis**: Tracks head pitch and yaw to detect nodding off or looking away from the road.
+    - **🧠 CNN Model Inference**: A deep learning model provides an additional layer of analysis.
+    
+    These signals are combined into a single drowsiness score to trigger alerts accurately.
+    """)
+
+with col2:
+    st.header("Current Configuration")
+    alert_method = "Gemini API" if config.get('gemini_api', {}).get('enabled') and gemini_api_key else "Static Audio File"
+    st.markdown(f"""
+    - **Detection Strategy**: `{config['detection_strategy']}`
+    - **Alert Method**: `{alert_method}`
+    """)
+    st.warning("Ensure good lighting and that your face is clearly visible for best results.")
+
+st.markdown("---")
+st.markdown("Created with ❤️ using Streamlit, OpenCV, and MediaPipe.")
+

models/best_model_efficientnet_b7.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b13c1e5e4f1a03e0e559ad8f7988c14b63d2b028c55f380814f241dd788a99df
+size 256870774

pages/1_Live_Detection.py

@@ -0,0 +1,153 @@
+# drive_paddy/pages/1_Live_Detection.py
+import streamlit as st
+from streamlit_webrtc import webrtc_streamer, RTCConfiguration, VideoProcessorBase
+import yaml
+import av
+import os
+from dotenv import load_dotenv
+import base64
+import queue
+import time
+
+from src.detection.factory import get_detector
+from src.alerting.alert_system import get_alerter
+
+# --- Load Configuration and Environment Variables ---
+@st.cache_resource
+def load_app_config():
+    """Loads config from yaml and .env files."""
+    load_dotenv()
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    # Navigate up to the root to find the config file
+    config_path = "/config.yaml" if os.path.exists("/config.yaml") else "config.yaml"
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    return config, gemini_api_key
+
+config, gemini_api_key = load_app_config()
+
+# --- Initialize Session State (if not already done in main.py) ---
+if "play_audio" not in st.session_state:
+    st.session_state.play_audio = None
+if "active_alerts" not in st.session_state:
+    st.session_state.active_alerts = {"status": "Awake"}
+
+# --- Client-Side Audio Playback Function ---
+def autoplay_audio(audio_bytes: bytes):
+    """Injects HTML to autoplay audio in the user's browser."""
+    b64 = base64.b64encode(audio_bytes).decode()
+    md = f"""
+        <audio controls autoplay="true" style="display:none;">
+        <source src="data:audio/mp3;base64,{b64}" type="audio/mp3">
+        </audio>
+        """
+    st.markdown(md, unsafe_allow_html=True)
+
+# --- WebRTC Video Processor ---
+class VideoProcessor(VideoProcessorBase):
+    def __init__(self):
+        self._detector = get_detector(config)
+        self._alerter = get_alerter(config, gemini_api_key)
+
+    def recv(self, frame: av.VideoFrame) -> av.VideoFrame:
+        img = frame.to_ndarray(format="bgr24")
+        
+        strategy = config.get('detection_strategy')
+        if strategy == 'hybrid':
+            processed_frame, alert_triggered, active_alerts = self._detector.process_frame(img)
+            st.session_state.active_alerts = active_alerts if alert_triggered else {"status": "Awake"}
+        else: # Fallback for simpler strategies
+            processed_frame, indicators = self._detector.process_frame(img)
+            alert_triggered = any(indicators.values())
+            st.session_state.active_alerts = indicators if alert_triggered else {"status": "Awake"}
+
+        if alert_triggered:
+            audio_data = self._alerter.trigger_alert()
+            if audio_data:
+                st.session_state.play_audio = audio_data
+        else:
+            self._alerter.reset_alert()
+            
+        return av.VideoFrame.from_ndarray(processed_frame, format="bgr24")
+
+# --- Page UI ---
+# The st.set_page_config() call has been removed from this file.
+# The configuration from main.py will apply to this page.
+st.title("📹 Live Drowsiness Detection")
+st.info("Press 'START' to activate your camera and begin monitoring.")
+
+# --- Robust RTC Configuration ---
+# Provide a list of STUN servers for better reliability.
+RTC_CONFIGURATION = RTCConfiguration({
+    "iceServers": [
+        {"urls": ["stun:stun.l.google.com:19302"]},
+        {"urls": ["stun:stun1.l.google.com:19302"]},
+        {"urls": ["stun:stun2.l.google.com:19302"]},
+        {"urls": ["stun:stun.services.mozilla.com:3478"]},
+    ]
+})
+
+
+col1, col2 = st.columns([3, 1])
+
+with col1:
+    webrtc_ctx = webrtc_streamer(
+        key="drowsiness-detection",
+        video_processor_factory=VideoProcessor,
+        rtc_configuration=RTC_CONFIGURATION, # Use the new robust configuration
+        media_stream_constraints={"video": True, "audio": False},
+        async_processing=True,
+    )
+
+with col2:
+    st.header("System Status")
+    if not webrtc_ctx.state.playing:
+        st.warning("System Inactive.")
+    else:
+        st.success("✅ System Active & Monitoring")
+
+    st.subheader("Live Status:")
+    status_placeholder = st.empty()
+    audio_placeholder = st.empty()
+
+if webrtc_ctx.state.playing:
+    # --- Polling Loop ---
+    try:
+        status_result = st.session_state.status_queue.get(timeout=0.1)
+    except queue.Empty:
+        status_result = None
+
+    # Check for new audio alerts
+    try:
+        audio_data = st.session_state.audio_queue.get(timeout=0.1)
+    except queue.Empty:
+        audio_data = None
+    
+    with status_placeholder.container():
+        # Persist the last known status if there's no new one
+        if status_result:
+            st.session_state.last_status = status_result
+        
+        last_status = getattr(st.session_state, 'last_status', {"status": "Awake"})
+        
+        if last_status.get("Low Light"):
+             st.warning("⚠️ Low Light Detected! Accuracy may be affected.")
+        elif last_status.get("status") == "Awake":
+            st.info("✔️ Driver is Awake")
+        else:
+            st.error("🚨 DROWSINESS DETECTED!")
+            for key, value in last_status.items():
+                if key != "Low Light":
+                    st.warning(f"-> {key}: {value:.2f}" if isinstance(value, float) else f"-> {key}")
+    
+    if audio_data:
+        with audio_placeholder.container():
+            autoplay_audio(audio_data)
+    
+    # Force a rerun to keep the polling active
+    time.sleep(0.1)
+    st.rerun()
+
+else:
+    with status_placeholder.container():
+        st.info("✔️ Driver is Awake")

requirements.txt

@@ -1,3 +1,15 @@
-altair
-pandas
-streamlit
+huggingface-hub
+streamlit
+streamlit-webrtc
+opencv-contrib-python
+mediapipe
+numpy
+pyyaml
+simpleaudio
+pydub
+python-dotenv           
+google-generativeai     
+gTTS                   
+torch                  
+torchvision            
+dlib                    

src/alerting/alert_system.py

@@ -0,0 +1,110 @@
+# drive_paddy/alerting/alert_system.py
+import time
+import os
+import io
+from gtts import gTTS
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+load_dotenv()  # Load environment variables from .env file
+
+api_key = os.getenv("GEMINI_API_KEY")
+class BaseAlerter:
+    """Base class for alerter systems."""
+    def __init__(self, config):
+        self.config = config['alerting']
+        self.cooldown = self.config['alert_cooldown_seconds']
+        self.last_alert_time = 0
+        self.alert_on = False
+
+    def trigger_alert(self):
+        raise NotImplementedError
+
+    def reset_alert(self):
+        if self.alert_on:
+            print("Resetting Alert.")
+            self.alert_on = False
+
+class FileAlertSystem(BaseAlerter):
+    """Loads a static audio file from disk into memory."""
+    def __init__(self, config):
+        super().__init__(config)
+        self.sound_path = self.config['alert_sound_path']
+        self.audio_bytes = None
+        try:
+            if os.path.exists(self.sound_path):
+                with open(self.sound_path, "rb") as f:
+                    self.audio_bytes = f.read()
+            else:
+                print(f"Warning: Alert sound file not found at '{self.sound_path}'.")
+        except Exception as e:
+            print(f"Warning: Could not load audio file. Error: {e}.")
+
+    def trigger_alert(self):
+        current_time = time.time()
+        if (current_time - self.last_alert_time) > self.cooldown:
+            if not self.alert_on and self.audio_bytes:
+                print("Triggering Static Alert!")
+                self.last_alert_time = current_time
+                self.alert_on = True
+                return self.audio_bytes # Return the audio data
+        return None
+
+
+class GeminiAlertSystem(BaseAlerter):
+    """Generates dynamic audio data using Gemini and gTTS."""
+    def __init__(self, config, api_key):
+        super().__init__(config)
+        try:
+            genai.configure(api_key=api_key)
+            self.model = genai.GenerativeModel('gemini-1.5-flash')  # Use the Gemini model
+            print("Gemini Alert System initialized successfully.")
+        except Exception as e:
+            print(f"Error initializing Gemini: {e}.")
+            self.model = None
+
+    def _generate_audio_data(self):
+        """Generates a unique alert message and returns it as audio bytes."""
+        if not self.model:
+            alert_text = "Stay alert!"
+        else:
+            prompt = "You are an AI driving assistant. Generate a short, friendly, but firm audio alert (under 10 words) for a driver showing signs of drowsiness."
+            try:
+                response = self.model.generate_content(prompt)
+                alert_text = response.text.strip().replace('*', '')
+            except Exception as e:
+                print(f"Error generating alert text with Gemini: {e}")
+                alert_text = "Wake up please!"
+        
+        print(f"Generated Alert Text: '{alert_text}'")
+        try:
+            # Generate TTS audio in memory
+            mp3_fp = io.BytesIO()
+            tts = gTTS(text=alert_text, lang='en')
+            tts.write_to_fp(mp3_fp)
+            mp3_fp.seek(0)
+            return mp3_fp.getvalue()
+        except Exception as e:
+            print(f"Error generating TTS audio: {e}")
+            return None
+
+    def trigger_alert(self):
+        current_time = time.time()
+        if (current_time - self.last_alert_time) > self.cooldown:
+            if not self.alert_on and self.model:
+                self.last_alert_time = current_time
+                self.alert_on = True
+                return self._generate_audio_data() # Return the audio data
+        return None
+
+
+def get_alerter(config, api_key=None):
+    """Factory to get the appropriate alerter based on config."""
+    use_gemini = config.get('gemini_api', {}).get('enabled', False)
+    
+    if use_gemini and api_key:
+        print("Initializing Gemini Alert System.")
+        return GeminiAlertSystem(config, api_key)
+    else:
+        print("Initializing standard File Alert System.")
+        return FileAlertSystem(config)

src/detection/base_processor.py

@@ -0,0 +1,26 @@
+# drive_paddy/detection/base_processor.py
+from abc import ABC, abstractmethod
+
+class BaseProcessor(ABC):
+    """
+    Abstract Base Class for a drowsiness detection processor.
+    
+    This defines the common interface that all detection strategies
+    (e.g., Geometric, CNN Model) must follow.
+    """
+    
+    @abstractmethod
+    def process_frame(self, frame):
+        """
+        Processes a single video frame to detect drowsiness.
+
+        Args:
+            frame: The video frame (as a NumPy array) to process.
+
+        Returns:
+            A tuple containing:
+            - The processed frame (NumPy array) with visualizations.
+            - A boolean indicating if an alert should be triggered.
+        """
+        pass
+

src/detection/factory.py

@@ -0,0 +1,22 @@
+# drive_paddy/detection/factory.py
+from src.detection.strategies.geometric import GeometricProcessor
+from src.detection.strategies.cnn_model import CnnProcessor
+from src.detection.strategies.hybrid import HybridProcessor
+
+def get_detector(config):
+    """
+    Factory function to get the appropriate drowsiness detector.
+    """
+    strategy = config.get('detection_strategy', 'geometric')
+    
+    if strategy == 'geometric':
+        print("Initializing Geometric drowsiness detector...")
+        return GeometricProcessor(config)
+    elif strategy == 'cnn_model':
+        print("Initializing CNN Model drowsiness detector...")
+        return CnnProcessor(config)
+    elif strategy == 'hybrid':
+        print("Initializing Hybrid (Geometric + CNN) drowsiness detector...")
+        return HybridProcessor(config)
+    else:
+        raise ValueError(f"Unknown detection strategy: {strategy}")

src/detection/strategies/cnn_model.py

@@ -0,0 +1,100 @@
+# drive_paddy/detection/strategies/cnn_model.py
+from src.detection.base_processor import BaseProcessor
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+from torchvision.models import efficientnet_b7
+import cv2
+import dlib
+from PIL import Image
+import os
+
+class CnnProcessor(BaseProcessor):
+    """
+    Drowsiness detection using a pre-trained EfficientNet-B7 model.
+    """
+    def __init__(self, config):
+        self.settings = config['cnn_model_settings']
+        self.model_path = self.settings['model_path']
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Initialize dlib for face detection
+        self.face_detector = dlib.get_frontal_face_detector()
+        
+        # Load the model
+        self.model = self._load_model()
+        
+        # Define image transformations
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ])
+
+    def _load_model(self):
+        """Loads the EfficientNet-B7 model and custom weights."""
+        if not os.path.exists(self.model_path):
+            print(f"Error: Model file not found at {self.model_path}")
+            print("Please run 'python download_model.py' first.")
+            return None
+            
+        try:
+            # Initialize the model structure
+            model = efficientnet_b7()
+            # Modify the final classifier layer to match the number of output classes (e.g., 2: drowsy, not_drowsy)
+            num_ftrs = model.classifier[1].in_features
+            model.classifier[1] = torch.nn.Linear(num_ftrs, 2) # Assuming 2 output classes
+
+            # Load the saved weights
+            model.load_state_dict(torch.load(self.model_path, map_location=self.device))
+            model.to(self.device)
+            model.eval() # Set the model to evaluation mode
+            print(f"CNN Model '{self.model_path}' loaded successfully on {self.device}.")
+            return model
+        except Exception as e:
+            print(f"Error loading CNN model: {e}")
+            return None
+
+    def process_frame(self, frame):
+        """
+        Processes a frame to detect drowsiness using the CNN model.
+        """
+        if self.model is None:
+            return frame, {"cnn_prediction": False}
+
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = self.face_detector(gray)
+        is_drowsy_prediction = False
+
+        for face in faces:
+            x1, y1, x2, y2 = face.left(), face.top(), face.right(), face.bottom()
+            
+            # Crop the face from the frame
+            face_crop = frame[y1:y2, x1:x2]
+            
+            # Ensure the crop is valid before processing
+            if face_crop.size == 0:
+                continue
+                
+            # Convert to PIL Image and apply transformations
+            pil_image = Image.fromarray(cv2.cvtColor(face_crop, cv2.COLOR_BGR2RGB))
+            image_tensor = self.transform(pil_image).unsqueeze(0).to(self.device)
+            
+            # Perform inference
+            with torch.no_grad():
+                outputs = self.model(image_tensor)
+                _, preds = torch.max(outputs, 1)
+                # Assuming class 1 is 'drowsy' and class 0 is 'not_drowsy'
+                print(preds)
+                if preds.item() == 1:
+                    is_drowsy_prediction = True
+
+            # Draw bounding box for visualization
+            cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 255, 0), 2)
+            label = "Drowsy" if is_drowsy_prediction else "Awake"
+            cv2.putText(frame, f"CNN: {label}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)
+            
+            # Process only the first detected face
+            break
+            
+        return frame, {"cnn_prediction": is_drowsy_prediction}

src/detection/strategies/geometric.py

@@ -0,0 +1,127 @@
+# drive_paddy/detection/strategies/geometric.py
+import cv2
+import mediapipe as mp
+import numpy as np
+import math
+from ..base_processor import BaseProcessor
+
+# --- Helper Functions ---
+def calculate_ear(eye_landmarks, frame_shape):
+    """Calculates the Eye Aspect Ratio (EAR)."""
+    # ... (implementation remains the same)
+    coords = np.array([(lm.x * frame_shape[1], lm.y * frame_shape[0]) for lm in eye_landmarks])
+    v1 = np.linalg.norm(coords[1] - coords[5]); v2 = np.linalg.norm(coords[2] - coords[4])
+    h1 = np.linalg.norm(coords[0] - coords[3])
+    return (v1 + v2) / (2.0 * h1) if h1 > 0 else 0.0
+
+def calculate_mar(mouth_landmarks, frame_shape):
+    """Calculates the Mouth Aspect Ratio (MAR) for yawn detection."""
+    coords = np.array([(lm.x * frame_shape[1], lm.y * frame_shape[0]) for lm in mouth_landmarks])
+    v1 = np.linalg.norm(coords[1] - coords[7]) # Vertical distances
+    v2 = np.linalg.norm(coords[2] - coords[6])
+    v3 = np.linalg.norm(coords[3] - coords[5])
+    h1 = np.linalg.norm(coords[0] - coords[4]) # Horizontal distance
+    return (v1 + v2 + v3) / (2.0 * h1) if h1 > 0 else 0.0
+
+class GeometricProcessor(BaseProcessor):
+    """
+    Drowsiness detection using a combination of facial landmarks:
+    - Eye Aspect Ratio (EAR) for eye closure.
+    - Mouth Aspect Ratio (MAR) for yawning.
+    - Head Pose Estimation for nodding off or looking away.
+    """
+    def __init__(self, config):
+        self.settings = config['geometric_settings']
+        self.face_mesh = mp.solutions.face_mesh.FaceMesh(
+            max_num_faces=1, refine_landmarks=True,
+            min_detection_confidence=0.5, min_tracking_confidence=0.5)
+
+        # State counters
+        self.counters = {
+            "eye_closure": 0, "yawning": 0,
+            "head_nod": 0, "looking_away": 0
+        }
+
+        # Landmark indices
+        self.L_EYE = [362, 385, 387, 263, 373, 380]
+        self.R_EYE = [33, 160, 158, 133, 153, 144]
+        self.MOUTH = [61, 291, 39, 181, 0, 17, 84, 178]
+
+    def process_frame(self, frame):
+        img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        h, w, _ = frame.shape
+        results = self.face_mesh.process(img_rgb)
+        
+        drowsiness_indicators = {
+            "eye_closure": False, "yawning": False,
+            "head_nod": False, "looking_away": False, "details": {}
+        }
+
+        if results.multi_face_landmarks:
+            landmarks = results.multi_face_landmarks[0].landmark
+            
+            # --- Eye Closure Detection (EAR) ---
+            left_ear = calculate_ear([landmarks[i] for i in self.L_EYE], (h, w))
+            right_ear = calculate_ear([landmarks[i] for i in self.R_EYE], (h, w))
+            ear = (left_ear + right_ear) / 2.0
+            if ear < self.settings['eye_ar_thresh']:
+                self.counters['eye_closure'] += 1
+                if self.counters['eye_closure'] >= self.settings['eye_ar_consec_frames']:
+                    drowsiness_indicators['eye_closure'] = True
+            else:
+                self.counters['eye_closure'] = 0
+            drowsiness_indicators['details']['EAR'] = ear
+
+            # --- Yawn Detection (MAR) ---
+            mar = calculate_mar([landmarks[i] for i in self.MOUTH], (h, w))
+            if mar > self.settings['yawn_mar_thresh']:
+                self.counters['yawning'] += 1
+                if self.counters['yawning'] >= self.settings['yawn_consec_frames']:
+                    drowsiness_indicators['yawning'] = True
+            else:
+                self.counters['yawning'] = 0
+            drowsiness_indicators['details']['MAR'] = mar
+                
+            # --- Head Pose Estimation ---
+            face_3d = 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
+            ], dtype=np.float64)
+            face_2d = np.array([
+                (landmarks[1].x * w, landmarks[1].y * h),   # Nose tip
+                (landmarks[152].x * w, landmarks[152].y * h), # Chin
+                (landmarks[263].x * w, landmarks[263].y * h), # Left eye corner
+                (landmarks[33].x * w, landmarks[33].y * h),   # Right eye corner
+                (landmarks[287].x * w, landmarks[287].y * h), # Left mouth corner
+                (landmarks[57].x * w, landmarks[57].y * h)   # Right mouth corner
+            ], dtype=np.float64)
+
+            cam_matrix = np.array([[w, 0, w / 2], [0, w, h / 2], [0, 0, 1]], dtype=np.float64)
+            _, rot_vec, _ = cv2.solvePnP(face_3d, face_2d, cam_matrix, np.zeros((4, 1), dtype=np.float64))
+            rmat, _ = cv2.Rodrigues(rot_vec)
+            angles, _, _, _, _, _ = cv2.RQDecomp3x3(rmat)
+            
+            pitch, yaw = angles[0], angles[1]
+            drowsiness_indicators['details']['Pitch'] = pitch
+            drowsiness_indicators['details']['Yaw'] = yaw
+
+            if pitch > self.settings['head_nod_thresh']:
+                self.counters['head_nod'] += 1
+                if self.counters['head_nod'] >= self.settings['head_pose_consec_frames']:
+                    drowsiness_indicators['head_nod'] = True
+            else:
+                self.counters['head_nod'] = 0
+
+            if abs(yaw) > self.settings['head_look_away_thresh']:
+                self.counters['looking_away'] += 1
+                if self.counters['looking_away'] >= self.settings['head_pose_consec_frames']:
+                    drowsiness_indicators['looking_away'] = True
+            else:
+                self.counters['looking_away'] = 0
+
+        # This processor now returns the frame and a dictionary of indicators
+        return frame, drowsiness_indicators

src/detection/strategies/hybrid.py

@@ -0,0 +1,84 @@
+# drive_paddy/detection/strategies/hybrid.py
+from src.detection.base_processor import BaseProcessor
+from src.detection.strategies.geometric import GeometricProcessor
+from src.detection.strategies.cnn_model import CnnProcessor
+import cv2
+import concurrent.futures
+
+class HybridProcessor(BaseProcessor):
+    """
+    Combines outputs from multiple detection strategies (Geometric and CNN)
+    concurrently to make a more robust and efficient drowsiness decision.
+    This version includes frame skipping for the CNN model to improve performance.
+    """
+    def __init__(self, config):
+        self.geometric_processor = GeometricProcessor(config)
+        self.cnn_processor = CnnProcessor(config)
+        self.weights = config['hybrid_settings']['weights']
+        self.alert_threshold = config['hybrid_settings']['alert_threshold']
+        self.active_alerts = {}
+        
+        # --- Performance Optimization ---
+        self.frame_counter = 0
+        self.cnn_process_interval = 10  # Run CNN every 10 frames
+        self.last_cnn_indicators = {"cnn_prediction": False} # Cache the last CNN result
+
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=2)
+
+    def process_frame(self, frame):
+        self.frame_counter += 1
+
+        # --- Concurrent Execution ---
+        # The geometric processor runs on every frame.
+        geo_future = self.executor.submit(self.geometric_processor.process_frame, frame.copy())
+
+        # The CNN processor only runs on specified intervals.
+        if self.frame_counter % self.cnn_process_interval == 0:
+            cnn_future = self.executor.submit(self.cnn_processor.process_frame, frame.copy())
+        
+        # Get the result from the geometric processor.
+        geo_frame, geo_indicators = geo_future.result()
+
+        # Get the CNN result if it was run, otherwise use the cached result.
+        if self.frame_counter % self.cnn_process_interval == 0:
+            _, self.last_cnn_indicators = cnn_future.result()
+        
+        cnn_indicators = self.last_cnn_indicators
+        
+        # Calculate weighted drowsiness score from the combined results.
+        score = 0
+        self.active_alerts.clear()
+
+        if geo_indicators.get("eye_closure"):
+            score += self.weights['eye_closure']
+            self.active_alerts['Eyes Closed'] = geo_indicators['details'].get('EAR', 0)
+        if geo_indicators.get("yawning"):
+            score += self.weights['yawning']
+            self.active_alerts['Yawning'] = geo_indicators['details'].get('MAR', 0)
+        if geo_indicators.get("head_nod"):
+            score += self.weights['head_nod']
+            self.active_alerts['Head Nod'] = geo_indicators['details'].get('Pitch', 0)
+        if geo_indicators.get("looking_away"):
+            score += self.weights['looking_away']
+            self.active_alerts['Looking Away'] = geo_indicators['details'].get('Yaw', 0)
+        if cnn_indicators.get("cnn_prediction"):
+            score += self.weights['cnn_prediction']
+            self.active_alerts['CNN Alert'] = 'Active'
+
+        # --- Visualization ---
+        output_frame = geo_frame
+        y_pos = 30
+        for alert, value in self.active_alerts.items():
+            text = f"{alert}: {value:.2f}" if isinstance(value, float) else alert
+            cv2.putText(output_frame, text, (10, y_pos), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
+            y_pos += 25
+            
+        cv2.putText(output_frame, f"Score: {score:.2f}", (output_frame.shape[1] - 150, 30),
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+
+        alert_triggered = score >= self.alert_threshold
+        if alert_triggered:
+            cv2.rectangle(output_frame, (0, 0), (output_frame.shape[1], output_frame.shape[0]), (0, 0, 255), 5)
+
+        # Return the processed frame, the alert trigger, and the active alert details
+        return output_frame, alert_triggered, self.active_alerts

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

utils.py

@@ -0,0 +1,76 @@
+# utils.py
+
+import numpy as np
+import cv2
+# Removed: import random, string, generate_gibberish
+
+# Function to calculate Eye Aspect Ratio (EAR)
+def calculate_ear(eye_landmarks, frame_shape):
+    """
+    Calculates the Eye Aspect Ratio (EAR) for a given eye.
+
+    Args:
+        eye_landmarks: A list of 6 MediaPipe landmark objects for the eye.
+                       Expected order: [p1, p2, p3, p4, p5, p6]
+                       where p1, p4 are horizontal extremes, and p2, p3, p5, p6
+                       are vertical extremes.
+        frame_shape: Tuple (height, width) of the frame.
+
+    Returns:
+        The calculated EAR value.
+    """
+    if len(eye_landmarks) != 6:
+        # print("Warning: Expected 6 eye landmarks, but received", len(eye_landmarks)) # Optional warning
+        return 0.0 # Return 0 or handle error appropriately
+
+    # Convert MediaPipe landmarks to numpy array (pixel coordinates)
+    coords = np.array([(landmark.x * frame_shape[1], landmark.y * frame_shape[0])
+                      for landmark in eye_landmarks])
+
+    # Calculate the Euclidean distances between the two sets of vertical eye landmarks
+    # p2-p6 and p3-p5
+    vertical_dist1 = np.linalg.norm(coords[1] - coords[5])
+    vertical_dist2 = np.linalg.norm(coords[2] - coords[4])
+
+    # Calculate the Euclidean distance between the horizontal eye landmark
+    # p1-p4
+    horizontal_dist = np.linalg.norm(coords[0] - coords[3])
+
+    # Calculate the EAR
+    # Avoid division by zero
+    if horizontal_dist == 0:
+        return 0.0
+
+    ear = (vertical_dist1 + vertical_dist2) / (2.0 * horizontal_dist)
+
+    return ear
+
+def draw_landmarks(image, landmarks, connections=None, point_color=(0, 255, 0), connection_color=(255, 255, 255)):
+    """
+    Draws landmarks and connections on the image.
+
+    Args:
+        image: The image (numpy array) to draw on.
+        landmarks: A list of MediaPipe landmark objects.
+        connections: A list of tuples representing landmark connections (e.g., [(0, 1), (1, 2)]).
+        point_color: Color for the landmarks (BGR tuple).
+        connection_color: Color for the connections (BGR tuple).
+    """
+    if not landmarks:
+        return image
+
+    img_h, img_w, _ = image.shape
+    landmark_points = [(int(l.x * img_w), int(l.y * img_h)) for l in landmarks]
+
+    # Draw connections
+    if connections:
+        for connection in connections:
+            p1 = landmark_points[connection[0]]
+            p2 = landmark_points[connection[1]]
+            cv2.line(image, p1, p2, connection_color, 1)
+
+    # Draw points
+    for point in landmark_points:
+         cv2.circle(image, point, 2, point_color, -1)
+
+    return image