Upload 9 files

Dockerfile

@@ -0,0 +1,89 @@
+# Dockerfile for Safe Driving Assistant
+
+# This container sets up a fully functional, headless-capable runtime environment
+# for the AI Safe Driving Assistant. It includes all necessary C/C++ build
+# dependencies for compiling dlib, PortAudio bindings (PyAudio), and sound/video
+# codecs, along with Xvfb (Virtual Framebuffer) to prevent OpenCV GUI crashes.
+
+# Use official lightweight Python base image
+FROM python:3.10-slim
+
+# Set environment variables to optimize Python performance and docker execution
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    DEBIAN_FRONTEND=noninteractive \
+    PULSE_SERVER=unix:/tmp/pulseaudio.socket \
+    FLASK_HOST=0.0.0.0
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Install system dependencies (build tools, audio, video, espeak, git, Xvfb)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    # Standard compilation and build utilities (required for compiling dlib and pyaudio) \
+    build-essential \
+    cmake \
+    g++ \
+    git \
+    gfortran \
+    pkg-config \
+    # Math libraries for optimization \
+    libopenblas-dev \
+    liblapack-dev \
+    # OpenCV / UI system dependencies \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libx11-dev \
+    # PortAudio & Audio libraries (required for PyAudio & SpeechRecognition) \
+    portaudio19-dev \
+    libasound2-dev \
+    alsa-utils \
+    pulseaudio \
+    # Pygame graphics/audio backends \
+    libsdl2-dev \
+    libsdl2-image-dev \
+    libsdl2-mixer-dev \
+    libsdl2-ttf-dev \
+    # Soundfile dependency \
+    libsndfile1 \
+    # Text-to-Speech (espeak) backend for pyttsx3 Linux fallback \
+    espeak \
+    libespeak-dev \
+    # Virtual Framebuffer (Xvfb) for headless OpenCV rendering (cv2.imshow) \
+    xvfb \
+    x11-apps \
+    # Cleanup to minimize image size \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel
+
+# Copy requirements.txt first to leverage Docker's build cache
+COPY requirements.txt .
+
+# Install dependencies (dlib, face_recognition, pyaudio, and scipy compilation can take a while)
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application files
+COPY . .
+
+# Expose Flask web HUD port (5000 by default in main.py)
+EXPOSE 5000
+
+# Create an entrypoint script to automatically spin up Xvfb and start the application
+RUN echo '#!/bin/bash\n\
+if [ -z "$DISPLAY" ]; then\n\
+    echo "[Docker-Entrypoint] No DISPLAY detected. Starting Virtual Framebuffer (Xvfb)..."\n\
+    Xvfb :99 -screen 0 640x480x24 &\n\
+    export DISPLAY=:99\n\
+    sleep 1\n\
+fi\n\
+echo "[Docker-Entrypoint] Starting Safe Driving Assistant..."\n\
+exec python main.py\n\
+' > /app/entrypoint.sh && chmod +x /app/entrypoint.sh
+
+# Use the virtual display entrypoint script
+ENTRYPOINT ["/app/entrypoint.sh"]

Modelfile

@@ -0,0 +1,30 @@
+FROM qwen2.5:3b
+
+# Set parameters for rich conversational abilities
+PARAMETER temperature 0.6
+PARAMETER top_p 0.9
+
+# Set system instructions
+SYSTEM """You are 'DriveSafe', a local safe driving AI chatbot and co-pilot. Your primary goal is to engage with the driver, answer their questions, and keep them awake, alert, and safe.
+Because the driver is currently driving, please follow these guidelines:
+1. Speak in a warm, helpful, natural, and conversational tone, like a real companion.
+2. Fully and intelligently answer the driver's questions. Do not truncate your answers artificially or enforce rigid word limits.
+3. Keep your answers clear, spoken-friendly, and conclude each response with a brief safety reminder or warm driving encouragement (e.g. 'Keep your eyes on the road!', 'Drive safely!', 'Stay focused!').
+
+SPECIAL ACTION TAGS FOR BACKEND ROUTING:
+1. MUSIC PLAYBACK: If the driver asks you to play any song, music, genre, or artist (e.g., 'play paint it black' or 'play some rock beats' or 'play taylor swift'), your response MUST be EXACTLY '[PLAY] ' followed by the name of the song, music, genre, or artist they requested. Do NOT add any other words, markdown, or chat text. 
+   Examples:
+   User: play paint it black -> Response: [PLAY] paint it black
+   User: play some rock music -> Response: [PLAY] rock music
+   User: play coldplay -> Response: [PLAY] coldplay
+
+2. MUSIC STOP: If the driver asks you to stop, pause, mute, or turn off the music/song (e.g., 'stop the music' or 'pause the song' or 'turn off sound'), your response MUST be EXACTLY '[STOP] ' followed by a brief confirmation.
+   Examples:
+   User: stop the music -> Response: [STOP] Stopping the music. Focus on driving!
+   User: pause the song -> Response: [STOP] Paused. Keep your eyes on the road.
+
+3. WARNING RESET: If the driver tells you they are awake, alert, or asks you to reset/clear the warnings, your response MUST start with '[RESET] ' followed by a brief encouraging confirmation.
+   Example:
+   User: reset warnings -> Response: [RESET] Warnings cleared. Keep your focus on the road.
+
+For general questions, stories, jokes, or safe-driving talk, reply as a highly conversational chatbot companion."""

README_DOCKER.md

@@ -0,0 +1,127 @@
+# 🚗 Safe Driving Assistant — Docker Integration Guide
+
+Welcome to the premium Docker integration guide for your **Safe Driving Assistant**. This guide provides step-by-step instructions on how to package, configure, build, and run the assistant inside a fully isolated, headless-capable Docker container.
+
+The containerized environment includes all C/C++ libraries, graphics backends, sound drivers, and speech synthesizers, pre-configured with a virtual framebuffer (**Xvfb**) to prevent OpenCV graphical crashes.
+
+---
+
+## 🌟 Highlights of the Docker Configuration
+
+*   **Zero-Dependency Setup:** No need to install `dlib`, `cmake`, `opencv`, or `pyaudio` manually on your host machine.
+*   **Virtual Framebuffer (Xvfb):** Headless-safe. If no display is detected, it automatically spawns a virtual X11 server so that `cv2.imshow` calls do not crash.
+*   **Dynamic Network Routing:** Pre-configured to easily bridge to your local **Ollama** SLM instance.
+*   **Unified Sound Backend:** Installs PulseAudio, ALSA, and `espeak` dependencies required for speech synthesis and playback.
+*   **Environment-Driven Configuration:** Highly customizable via environment variables (`FLASK_HOST`, `CAMERA_ID`, `OLLAMA_API_URL`, etc.).
+
+---
+
+## 🛠️ Step 1: Build the Docker Image
+
+Open your terminal in the project directory (`Safe Driving Assistant`) and run the following command to build your custom co-pilot image:
+
+```bash
+docker build -t safe-driving-assistant:latest .
+```
+
+*This compilation will take several minutes during the first run because it builds `dlib` (facial recognition) and compiles native C extensions.*
+
+---
+
+## 🚀 Step 2: Run the Docker Container
+
+Depending on your host Operating System and hardware setup, select one of the premium run configurations below:
+
+### Option A: Standard Headless / Web-HUD Only (Recommended)
+This runs the assistant, serves the live futuristic Web-HUD on port `5000`, and bridges network queries to your host's local Ollama service.
+
+```bash
+docker run -d \
+  --name driving_assistant \
+  --add-host=host.docker.internal:host-gateway \
+  -e OLLAMA_API_URL="http://host.docker.internal:11434/api/generate" \
+  -p 5000:5000 \
+  safe-driving-assistant:latest
+```
+
+*   **Web Dashboard:** Once started, open your browser and navigate to **`http://localhost:5000`** to view the live dashboard!
+*   **How it works:** The container runs headlessly. Face recognition and eye-aspect ratio tracking are active, and the live stream is pushed directly to the dashboard.
+
+---
+
+### Option B: Linux Run with Full Hardware Passthrough (Camera & Audio)
+If you are running native Linux and want the container to access your physical USB webcam and audio hardware directly, run:
+
+```bash
+docker run -it \
+  --name driving_assistant \
+  --device /dev/video0:/dev/video0 \
+  --device /dev/snd:/dev/snd \
+  --add-host=host.docker.internal:host-gateway \
+  -e CAMERA_ID=0 \
+  -e OLLAMA_API_URL="http://host.docker.internal:11434/api/generate" \
+  -p 5000:5000 \
+  safe-driving-assistant:latest
+```
+
+*   **`--device /dev/video0`:** Mounts your primary webcam inside the container.
+*   **`--device /dev/snd`:** Exposes speaker and mic controls.
+
+---
+
+### Option C: Windows Host (WSL2) with Web USB Webcam Passthrough
+If you are using WSL2 on Windows and want to feed your physical webcam into the Docker container:
+
+1.  Bind your USB camera to WSL2 using [usbipd-win](https://github.com/dorssel/usbipd-win):
+    ```powershell
+    usbipd list
+    usbipd bind --busid <BUSID>
+    usbipd attach --wsl --busid <BUSID>
+    ```
+2.  Start the container with device mapping:
+    ```bash
+    docker run -it \
+      --name driving_assistant \
+      --device /dev/video0:/dev/video0 \
+      --add-host=host.docker.internal:host-gateway \
+      -e CAMERA_ID=0 \
+      -e OLLAMA_API_URL="http://host.docker.internal:11434/api/generate" \
+      -p 5000:5000 \
+      safe-driving-assistant:latest
+    ```
+
+---
+
+## ⚙️ Environment Variables Customization
+
+You can dynamically tune your assistant container at runtime by passing `-e KEY=VALUE` parameters to `docker run`:
+
+| Variable Name | Default Value | Description |
+| :--- | :--- | :--- |
+| `FLASK_HOST` | `0.0.0.0` | Binding IP address for Flask web dashboard. |
+| `FLASK_PORT` | `5000` | Port on which the web HUD dashboard will be served. |
+| `CAMERA_ID` | `0` | Camera index. |
+| `OLLAMA_API_URL` | `http://localhost:11434/api/generate` | The API endpoint for the Ollama voice co-pilot. Use `http://host.docker.internal:11434/api/generate` for bridging to host. |
+| `OLLAMA_MODEL` | `drivesafe` | Name of the custom SLM model configured inside Ollama. |
+| `FRAME_WIDTH` | `640` | Video frame capture width. |
+| `FRAME_HEIGHT` | `480` | Video frame capture height. |
+
+---
+
+## 🧼 Housekeeping & Diagnostics
+
+### View Real-Time Logs
+To see the system warnings, detected EAR, and conversational chatbot interactions:
+```bash
+docker logs -f driving_assistant
+```
+
+### Stop & Remove Container
+To stop and clean up the assistant container instance:
+```bash
+docker stop driving_assistant
+docker rm driving_assistant
+```
+
+---
+**Safe Driving Assistant** — *Keep your eyes on the road, your hands on the wheel, and drive safely!* 🚗💨

main.py

@@ -0,0 +1,966 @@
+"""
+main.py — Self-Contained, Fully Integrated Safe Driving Assistant
+Consolidates all system configuration, custom non-blocking sound synthesizer, dlib Eye Landmark processor,
+Ollama SLM action voice-assistant parser, Flask SSE Telemetry Dashboard, and main drowsiness timer logic
+into one unified, ultra-premium script.
+"""
+
+import os
+import sys
+import time
+import json
+import queue
+import collections
+import threading
+import logging
+import urllib.request
+import urllib.parse
+import webbrowser
+import re
+
+import numpy as np
+import scipy.io.wavfile as wavfile
+import pygame
+import pyttsx3
+import cv2
+import face_recognition
+import speech_recognition as sr
+from flask import Flask, render_template, Response, jsonify, request
+
+
+#  1. DriveSafe Assistant — Configuration Settings
+CAMERA_ID = int(os.environ.get("CAMERA_ID", 0))              # Index of the webcam (usually 0)
+FRAME_WIDTH = int(os.environ.get("FRAME_WIDTH", 640))          # Video capture width
+FRAME_HEIGHT = int(os.environ.get("FRAME_HEIGHT", 480))         # Video capture height
+
+# Drowsiness Detection Thresholds
+EAR_THRESHOLD = 0.23       # Eye Aspect Ratio below this indicates closed eyes
+EAR_CONSEC_FRAMES = 3      # Consecutive frames below threshold to trigger eye-closed timer
+
+# Alert Severity Levels (Durations in Seconds)
+ALERT_LEVEL1_MIN = 3.0     # Min duration of closed eyes for Level 1 ("stay focused")
+ALERT_LEVEL1_MAX = 5.0     # Max duration of closed eyes for Level 1
+ALERT_LEVEL2_MIN = 5.0     # Closed eyes duration for Level 2 ("wake up stay focus on road" louder)
+
+# Frequent Drowsiness Pattern Tracking
+FREQUENT_DROWSY_WINDOW = 60.0  # Sliding window (seconds) to monitor drowsiness event frequency
+FREQUENT_DROWSY_LIMIT = 2      # Max drowsiness warnings allowed in window before advising a break (Level 3)
+
+# Voice Assistant & SLM Settings
+OLLAMA_MODEL = os.environ.get("OLLAMA_MODEL", "drivesafe")                  # Our custom local Ollama model
+OLLAMA_API_URL = os.environ.get("OLLAMA_API_URL", "http://localhost:11434/api/generate") # Ollama generation endpoint
+SPEECH_RECOGNITION_TIMEOUT = 10             # Timeout for speech recognizer
+WAKE_WORD = "assistant"                    # Wake word for general conversations
+
+# Web HUD Dashboard Server
+FLASK_HOST = os.environ.get("FLASK_HOST", "127.0.0.1")
+FLASK_PORT = int(os.environ.get("FLASK_PORT", 5000))
+
+# High Energy Music Links
+ENERGETIC_MUSIC_URL = "https://music.youtube.com/playlist?list=PLYBSqm--lNVt1H63PlRvigxvPU_unQe8m"
+
+#  2. Flask Web HUD Server & Shared DashboardState
+
+# Initialize Flask app
+app = Flask(__name__, template_folder='templates', static_folder='static')
+
+# Thread-safe global state for Flask-main loop communication
+class DashboardState:
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.latest_frame = None
+        self.ear = 0.0
+        self.state = "NORMAL"
+        self.drowsiness_count = 0
+        self.fps = 0
+        self.alert_message = ""
+        self.chat_history = []
+        self.detection_active = True
+
+dashboard_state = DashboardState()
+
+@app.route('/')
+def index():
+    """Renders the futuristic cyberpunk HUD dashboard."""
+    return render_template('index.html')
+
+def gen_video_feed():
+    """Generator function that yields JPEG frames for the live camera stream."""
+    while True:
+        with dashboard_state.lock:
+            if dashboard_state.latest_frame is None:
+                frame_to_send = None
+            else:
+                frame_to_send = dashboard_state.latest_frame.copy()
+                
+        if frame_to_send is not None:
+            # Encode BGR OpenCV frame to standard JPEG
+            ret, jpeg = cv2.imencode('.jpg', frame_to_send)
+            if ret:
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n\r\n' + jpeg.tobytes() + b'\r\n\r\n')
+        
+        # Frame-rate limiter (30 FPS max for the web stream to keep networking lightweight)
+        time.sleep(1.0 / 30.0)
+
+@app.route('/video_feed')
+def video_feed():
+    """Serves the real-time annotated video stream inside standard HTML img tags."""
+    return Response(gen_video_feed(),
+                    mimetype='multipart/x-mixed-replace; boundary=frame')
+
+def gen_telemetry_stream():
+    """Streams real-time system diagnostics to the browser via HTML5 Server-Sent Events (SSE)."""
+    last_sent_time = 0
+    while True:
+        # Throttle telemetry updates slightly (e.g. 15 updates/second) to keep browser rendering butter-smooth
+        current_time = time.time()
+        if current_time - last_sent_time >= 0.06:
+            with dashboard_state.lock:
+                data = {
+                    "ear": round(dashboard_state.ear, 3),
+                    "state": dashboard_state.state,
+                    "drowsiness_count": dashboard_state.drowsiness_count,
+                    "fps": dashboard_state.fps,
+                    "alert_message": dashboard_state.alert_message,
+                    "chat_history": dashboard_state.chat_history,
+                    "detection_active": dashboard_state.detection_active
+                }
+            
+            # SSE data format: "data: <json>\n\n"
+            yield f"data: {json.dumps(data)}\n\n"
+            last_sent_time = current_time
+            
+        time.sleep(0.01)
+
+@app.route('/telemetry')
+def telemetry():
+    """SSE endpoint for high-speed diagnostic telemetry streaming."""
+    return Response(gen_telemetry_stream(), mimetype='text/event-stream')
+
+# Interactive Control APIs
+
+@app.route('/api/toggle_detection', methods=['POST'])
+def toggle_detection():
+    """Enables or disables active face and eye tracking."""
+    with dashboard_state.lock:
+        dashboard_state.detection_active = not dashboard_state.detection_active
+        status = dashboard_state.detection_active
+    return jsonify({"status": "success", "detection_active": status})
+
+@app.route('/api/reset', methods=['POST'])
+def api_reset():
+    """Triggers a complete system reset from the dashboard panel."""
+    if hasattr(app, 'reset_callback') and app.reset_callback:
+        app.reset_callback()
+        return jsonify({"status": "success", "message": "System alerts and warning log reset."})
+    return jsonify({"status": "error", "message": "Reset callback not configured."})
+
+@app.route('/api/trigger_music', methods=['POST'])
+def api_trigger_music():
+    """Manually triggers the energetic song from the dashboard panel."""
+    if hasattr(app, 'play_music_callback') and app.play_music_callback:
+        app.play_music_callback()
+        return jsonify({"status": "success", "message": "Playing energetic synthwave music!"})
+    return jsonify({"status": "error", "message": "Music callback not configured."})
+
+def start_server_async():
+    """Runs the Flask development server on a dedicated background thread."""
+    # Suppress Flask development server startup messages to keep terminal clean
+    log = logging.getLogger('werkzeug')
+    log.setLevel(logging.ERROR)
+    
+    server_thread = threading.Thread(
+        target=lambda: app.run(host=FLASK_HOST, port=FLASK_PORT, debug=False, use_reloader=False),
+        daemon=True
+    )
+    server_thread.start()
+    print(f"[Flask Server] Running in background at http://{FLASK_HOST}:{FLASK_PORT}")
+
+# 3. AlertManager — Programmatic Sound Synthesis & Multi-Threaded Audio
+class AlertManager:
+    def __init__(self):
+        # Ensure directories exist
+        os.makedirs("audio", exist_ok=True)
+        
+        # Programmatically synthesize our warning and chime audio files
+        self._synthesize_audio_assets()
+        
+        # Initialize Pygame Mixer for non-blocking SFX playback
+        pygame.mixer.init()
+        
+        # Audio file paths
+        self.calm_beep_path = os.path.join("audio", "calm_beep.wav")
+        self.urgent_beep_path = os.path.join("audio", "urgent_beep.wav")
+        
+        # Thread-safe speech queue & worker setup
+        self.speech_queue = queue.Queue()
+        self.is_speaking = False
+        self.speech_thread = threading.Thread(target=self._speech_worker, daemon=True)
+        self.speech_thread.start()
+
+    def _synthesize_audio_assets(self):
+        """Synthesizes custom chime and alert WAV files using numpy and scipy."""
+        sample_rate = 44100
+        
+        # 1. Calm chime (gentle 550Hz sine wave decaying)
+        duration = 0.4
+        t = np.linspace(0, duration, int(sample_rate * duration), False)
+        envelope = np.exp(-5 * t)  # decay envelope
+        tone = np.sin(2 * np.pi * 550 * t) * envelope
+        calm_data = (tone * 20000).astype(np.int16)
+        wavfile.write(os.path.join("audio", "calm_beep.wav"), sample_rate, calm_data)
+        
+        # 2. Urgent pulsing beeps (three rapid 1200Hz pulse bursts)
+        urgent_data = []
+        burst_duration = 0.08
+        gap_duration = 0.05
+        t_burst = np.linspace(0, burst_duration, int(sample_rate * burst_duration), False)
+        burst = np.sin(2 * np.pi * 1200 * t_burst) * 32000
+        gap = np.zeros(int(sample_rate * gap_duration))
+        
+        # Combine three bursts
+        for _ in range(3):
+            urgent_data.extend(burst)
+            urgent_data.extend(gap)
+            
+        urgent_np = np.array(urgent_data, dtype=np.int16)
+        wavfile.write(os.path.join("audio", "urgent_beep.wav"), sample_rate, urgent_np)
+
+    def _speech_worker(self):
+        """Background worker thread that serializes all speech requests using native PowerShell synthesis to prevent COM/threading locks."""
+        print("[AlertManager] Speech worker thread active.")
+        import subprocess
+        while True:
+            try:
+                # Blocks until an item is available
+                text, volume, rate = self.speech_queue.get()
+                
+                self.is_speaking = True
+                
+                # Escape single quotes and backslashes for PowerShell safety
+                escaped_text = text.replace("\\", "\\\\").replace("'", "''")
+                
+                # Map rate (150-190) to PowerShell Rate (-10 to 10)
+                ps_rate = 0
+                if rate > 180:
+                    ps_rate = 2
+                elif rate < 150:
+                    ps_rate = -2
+                    
+                # Map volume (0.0 to 1.0) to PowerShell Volume (0 to 100)
+                ps_volume = int(volume * 100)
+                
+                ps_command = (
+                    f"Add-Type -AssemblyName System.Speech; "
+                    f"$speak = New-Object System.Speech.Synthesis.SpeechSynthesizer; "
+                    f"$speak.Rate = {ps_rate}; "
+                    f"$speak.Volume = {ps_volume}; "
+                    f"$speak.Speak('{escaped_text}')"
+                )
+                
+                # Run synchronously inside the worker thread to maintain sequential speech
+                subprocess.run(
+                    ["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", ps_command],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL
+                )
+                
+                self.is_speaking = False
+                self.speech_queue.task_done()
+            except Exception as e:
+                print(f"[AlertManager] Speech worker exception: {e}")
+                self.is_speaking = False
+                time.sleep(0.5)
+
+    def speak(self, text, volume=0.8, rate=170):
+        """Enqueues a text string to be spoken in the background thread."""
+        self.speech_queue.put((text, volume, rate))
+
+    def trigger_level1(self):
+        """Level 1 Alert (3-5s closed): Soft chime, then calm voice."""
+        print("[AlertManager] Triggering Level 1 Alert: Calm Stay Focused")
+        pygame.mixer.Sound(self.calm_beep_path).play()
+        self.speak("Stay focused on the road", volume=0.7, rate=160)
+
+    def trigger_level2(self):
+        """Level 2 Alert (>5s closed): Loud siren beep, then loud voice."""
+        print("[AlertManager] Triggering Level 2 Alert: Loud WAKE UP!")
+        pygame.mixer.Sound(self.urgent_beep_path).play()
+        self.speak("Wake up! Stay focused on the road!", volume=1.0, rate=190)
+
+    def trigger_level3_advisory(self):
+        """Level 3 Alert (Frequent drowsiness): Ask to take a rest break on the side."""
+        print("[AlertManager] Triggering Level 3 Alert: Rest break advisory")
+        pygame.mixer.Sound(self.urgent_beep_path).play()
+        self.speak("You are getting drowsy frequently. Please pull over on the side and take a rest.", volume=0.9, rate=170)
+
+    def ask_energetic_song(self):
+        """Ask the driver if they want to listen to an energetic song."""
+        print("[AlertManager] Querying driver for energetic song")
+        self.speak("Alright. Would you like to listen to an energetic song to help you stay awake?", volume=0.85, rate=170)
+
+    def play_energetic_music(self):
+        """Announce and play energetic music."""
+        print("[AlertManager] Playing energetic music")
+        self.speak("Playing some high energy synthwave beats. Turn it up and stay alert!", volume=0.9, rate=170)
+        webbrowser.open(ENERGETIC_MUSIC_URL)
+
+
+# 4. EyeDetector — 2x Downsampling dlib Eye Landmark Processor with Fallback
+
+class EyeDetector:
+    def __init__(self):
+        self.scale_factor = 2  # Resizes to 50% width/height (4x speedup)
+        self.last_warning_time = 0
+
+    def _calculate_ear(self, eye_points):
+        """Calculates the Eye Aspect Ratio (EAR) for a single eye list of 6 points."""
+        p1 = np.array(eye_points[0])
+        p2 = np.array(eye_points[1])
+        p3 = np.array(eye_points[2])
+        p4 = np.array(eye_points[3])
+        p5 = np.array(eye_points[4])
+        p6 = np.array(eye_points[5])
+        
+        vertical1 = np.linalg.norm(p2 - p6)
+        vertical2 = np.linalg.norm(p3 - p5)
+        horizontal = np.linalg.norm(p1 - p4)
+        
+        if horizontal == 0:
+            return 0.0
+            
+        return (vertical1 + vertical2) / (2.0 * horizontal)
+
+    def process_frame(self, frame):
+        """Processes a single BGR camera frame with a robust full-res fallback."""
+        height, width, _ = frame.shape
+        debug_frame = frame.copy()
+        
+        # 1. Downsample the frame for high-speed face detection
+        small_frame = cv2.resize(frame, (0, 0), fx=1.0/self.scale_factor, fy=1.0/self.scale_factor)
+        rgb_small_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)
+        
+        # 2. Try fast downscaled detection first
+        face_landmarks_list = face_recognition.face_landmarks(rgb_small_frame)
+        current_scale = self.scale_factor
+        
+        # 3. Fallback: If no face found in small frame, try the full-resolution frame!
+        if not face_landmarks_list:
+            rgb_full_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            face_landmarks_list = face_recognition.face_landmarks(rgb_full_frame)
+            current_scale = 1
+        
+        avg_ear = None
+        landmarks_found = None
+        
+        if face_landmarks_list:
+            face_landmarks = face_landmarks_list[0]
+            landmarks_found = face_landmarks
+            
+            left_eye_raw = face_landmarks.get('left_eye', [])
+            right_eye_raw = face_landmarks.get('right_eye', [])
+            
+            if len(left_eye_raw) == 6 and len(right_eye_raw) == 6:
+                # Scale coordinates back up to original frame dimensions
+                left_eye = [(int(x * current_scale), int(y * current_scale)) for (x, y) in left_eye_raw]
+                right_eye = [(int(x * current_scale), int(y * current_scale)) for (x, y) in right_eye_raw]
+                
+                left_ear = self._calculate_ear(left_eye)
+                right_ear = self._calculate_ear(right_eye)
+                avg_ear = (left_ear + right_ear) / 2.0
+                
+                # Draw the glowing tech HUD outlines
+                self._draw_eye_hud(debug_frame, left_eye, right_eye, avg_ear)
+        else:
+            # No face detected! Print throttled console warning and show overlay text
+            current_time = time.time()
+            if current_time - self.last_warning_time > 2.5:
+                print("[EyeDetector] WARNING: No face detected in camera stream! Adjust position or lighting.")
+                self.last_warning_time = current_time
+                
+            # Draw warning overlay on dashboard feed
+            cv2.putText(debug_frame, "NO FACE DETECTED", (width // 2 - 120, height // 2), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+            cv2.putText(debug_frame, "Adjust Camera / Lighting", (width // 2 - 140, height // 2 + 30), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 165, 255), 1)
+                
+        return avg_ear, landmarks_found, debug_frame
+
+    def _draw_eye_hud(self, frame, left_eye, right_eye, ear):
+        """Draws glowing HUD tech contours on eyes and shows EAR readout."""
+        if ear is not None and ear < EAR_THRESHOLD:
+            color = (0, 0, 255)       # Red: Closed/Drowsy
+            thickness = 2
+        else:
+            color = (0, 255, 0)       # Green: Open/Safe
+            thickness = 1
+            
+        left_pts = np.array(left_eye, np.int32)
+        cv2.polylines(frame, [left_pts], True, color, thickness)
+        
+        right_pts = np.array(right_eye, np.int32)
+        cv2.polylines(frame, [right_pts], True, color, thickness)
+        
+        for (x, y) in left_eye + right_eye:
+            cv2.circle(frame, (x, y), 2, (255, 255, 0), -1)
+            
+        if ear is not None:
+            text = f"EAR: {ear:.2f}"
+            cv2.putText(frame, text, (30, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
+
+
+# 5. VoiceAssistant — Dynamic Action Router & Background Speech Recognition
+
+class VoiceAssistant:
+    def __init__(self, alert_manager, state_callbacks):
+        self.alert_manager = alert_manager
+        self.callbacks = state_callbacks
+        
+        self.recognizer = sr.Recognizer()
+        self.recognizer.energy_threshold = 4000
+        self.recognizer.dynamic_energy_threshold = True
+        
+        self.running = True
+        self.thread = threading.Thread(target=self._assistant_loop, daemon=True)
+        self.thread.start()
+
+    def query_ollama_slm(self, prompt):
+        """Sends user transcription to the local custom drivesafe SLM on Ollama."""
+        payload = {
+            "model": OLLAMA_MODEL,
+            "prompt": prompt,
+            "stream": False
+        }
+        headers = {"Content-Type": "application/json"}
+        
+        try:
+            req = urllib.request.Request(
+                OLLAMA_API_URL,
+                data=json.dumps(payload).encode("utf-8"),
+                headers=headers,
+                method="POST"
+            )
+            # Use a 10-second timeout to accommodate initial Ollama cold start weight loading
+            with urllib.request.urlopen(req, timeout=10) as response:
+                res_data = json.loads(response.read().decode("utf-8"))
+                reply = res_data.get("response", "").strip()
+                # Clean up any quotes or markdown from the SLM
+                reply = reply.replace('"', '').replace('*', '').strip()
+                return reply
+        except Exception as e:
+            print(f"[Ollama SLM] Error or timeout querying local model: {e}")
+            lower_prompt = prompt.lower()
+            if "hello" in lower_prompt or "hi" in lower_prompt:
+                return "Hello! I am here. Eyes on the road, friend."
+            elif "joke" in lower_prompt:
+                return "Why did the scarecrow win an award? Because he was outstanding in his field. Stay alert!"
+            else:
+                return "Understood. Keep driving safely, stay focused on the road."
+
+    def _assistant_loop(self):
+        """Background continuous microphone listening loop."""
+        print("[VoiceAssistant] Speech recognizer thread started.")
+        
+        try:
+            mic = sr.Microphone()
+        except Exception as e:
+            print(f"[VoiceAssistant] Error accessing microphone: {e}. Voice controls disabled.")
+            return
+            
+        with mic as source:
+            print("[VoiceAssistant] Calibrating microphone for driving background noise...")
+            self.recognizer.adjust_for_ambient_noise(source, duration=2)
+            print("[VoiceAssistant] Calibration complete. Ready for voice interaction.")
+            
+            while self.running:
+                if self.alert_manager.is_speaking:
+                    time.sleep(0.3)
+                    continue
+                    
+                try:
+                    audio = self.recognizer.listen(source, timeout=1.5, phrase_time_limit=4.0)
+                except sr.WaitTimeoutError:
+                    continue
+                except Exception as e:
+                    print(f"[VoiceAssistant] Microphone capture error: {e}")
+                    time.sleep(0.5)
+                    continue
+
+                if self.alert_manager.is_speaking:
+                    continue
+
+                # Run speech recognition in a separate thread to keep mic pipeline responsive
+                threading.Thread(target=self._process_audio, args=(audio,), daemon=True).start()
+
+    def _process_audio(self, audio):
+        """Recognizes speech and routes commands dynamically."""
+        try:
+            text = self.recognizer.recognize_google(audio)
+            print(f"[Driver Heard] {text}")
+        except sr.UnknownValueError:
+            return
+        except sr.RequestError:
+            try:
+                print("[VoiceAssistant] Cloud Speech API unavailable. Attempting local Whisper...")
+                text = self.recognizer.recognize_whisper(audio, model="base.en")
+                print(f"[Driver Heard (Whisper)] {text}")
+            except Exception as e:
+                print(f"[VoiceAssistant] Offline recognition failed: {e}")
+                return
+                
+        cleaned_text = text.strip().lower()
+        if not cleaned_text:
+            return
+
+        # STATE-SPECIFIC ROUTING (Emergency Rest / Song Prompts)
+        current_state = self.callbacks['get_system_state']()
+        
+        # 1. State: Driver has been warned of frequent drowsiness (Level 3 Advisory)
+        if current_state == "WAITING_REST_RESPONSE":
+            refusal_words = ["no", "never", "can't", "wont", "won't", "refuse", "impossible", "fine", "good", "no thanks", "no rest", "keep driving"]
+            accepted_words = ["yes", "yeah", "ok", "okay", "fine I will", "sure", "pulling over"]
+            
+            if any(word in cleaned_text for word in refusal_words):
+                print("[VoiceAssistant] Driver refused rest. Prompting for energetic song.")
+                self.callbacks['set_system_state']("WAITING_SONG_RESPONSE")
+                self.callbacks['add_chat_log'](text, "No, I'm fine. I won't stop.")
+                
+                time.sleep(0.5)
+                self.alert_manager.ask_energetic_song()
+                self.callbacks['add_chat_log']("System", "Alright. Would you like to listen to an energetic song to help you stay awake?")
+                return
+                
+            elif any(word in cleaned_text for word in accepted_words) or "pull" in cleaned_text:
+                print("[VoiceAssistant] Driver accepted rest.")
+                self.callbacks['reset_warnings']()
+                self.callbacks['add_chat_log'](text, "Okay, pulling over.")
+                self.alert_manager.speak("Good decision. Pull over safely and take some rest.")
+                self.callbacks['add_chat_log']("System", "Good decision. Pull over safely and take some rest.")
+                return
+
+        # 2. State: Driver refused rest, now confirming if they want a song
+        elif current_state == "WAITING_SONG_RESPONSE":
+            accepted_words = ["yes", "yeah", "sure", "ok", "okay", "play", "song", "music", "please"]
+            
+            if any(word in cleaned_text for word in accepted_words):
+                print("[VoiceAssistant] Driver accepted song.")
+                self.callbacks['add_chat_log'](text, "Yes, play some music.")
+                self.alert_manager.play_energetic_music()
+                self.callbacks['add_chat_log']("System", "Playing energetic synthwave beats! Stay awake!")
+                self.callbacks['set_system_state']("PLAYING_MUSIC")
+                return
+            else:
+                print("[VoiceAssistant] Driver declined song.")
+                self.callbacks['add_chat_log'](text, "No, I'm okay.")
+                self.alert_manager.speak("Understood. Keep your eyes on the road. Stay focused.")
+                self.callbacks['add_chat_log']("System", "Understood. Keep your eyes on the road. Stay focused.")
+                self.callbacks['reset_warnings']()
+                return
+
+        # DIRECT SYSTEM BACKUP COMMANDS (Local Regex Override)
+        if "reset" in cleaned_text or "clear" in cleaned_text or "awake" in cleaned_text or "focused" in cleaned_text:
+            print("[VoiceAssistant] Safe state reset command received.")
+            self.callbacks['reset_warnings']()
+            self.callbacks['add_chat_log'](text, "Reset assistant")
+            self.alert_manager.speak("System reset. Let's keep driving safely.")
+            self.callbacks['add_chat_log']("System", "System reset. Let's keep driving safely.")
+            return
+            
+        has_play = any(p in cleaned_text for p in ["play", "start", "turn on", "listen", "put on", "launch"])
+        has_music_kw = any(kw in cleaned_text for kw in ["music", "song", "beat", "tune", "track", "musc", "melody", "audio", "lofi"])
+        
+        if has_play:
+            # Extract query after the play keyword
+            play_keyword = next((p for p in ["play", "start", "turn on", "listen to", "put on", "launch"] if p in cleaned_text), "play")
+            idx = cleaned_text.find(play_keyword)
+            music_query = cleaned_text[idx + len(play_keyword):].strip()
+            
+            # Clean common filler words
+            for filler in ["some", "a", "the", "music", "song", "track", "musc"]:
+                if music_query.startswith(filler):
+                    music_query = music_query[len(filler):].strip()
+                if music_query.endswith(filler):
+                    music_query = music_query[:-len(filler)].strip()
+            
+            # If the remaining query is empty or generic, play the custom playlist
+            if not music_query or music_query in ["music", "song", "beat", "tune", "track", "musc", "melody"]:
+                print("[VoiceAssistant] General music command recognized locally. Playing playlist.")
+                self.callbacks['add_chat_log'](text, "Requested general music playback")
+                self.alert_manager.play_energetic_music()
+                self.callbacks['set_system_state']("PLAYING_MUSIC")
+                return
+            else:
+                # Play specific song directly!
+                print(f"[VoiceAssistant] Specific song command recognized locally: {music_query}")
+                confirm_msg = f"Sure thing! Autoplay in progress for {music_query}."
+                self.callbacks['add_chat_log'](text, confirm_msg)
+                self.alert_manager.speak(confirm_msg)
+                
+                # Fetch first search result and autoplay!
+                search_url = f"https://www.youtube.com/results?search_query={urllib.parse.quote(music_query)}"
+                headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
+                try:
+                    req = urllib.request.Request(search_url, headers=headers)
+                    with urllib.request.urlopen(req, timeout=5) as res:
+                        html = res.read().decode('utf-8')
+                        video_ids = re.findall(r'/watch\?v=([a-zA-Z0-9_-]{11})', html)
+                        if video_ids:
+                            first_video_id = video_ids[0]
+                            direct_url = f"https://www.youtube.com/watch?v={first_video_id}&autoplay=1"
+                            print(f"[VoiceAssistant] Auto-playing first matching YouTube video: {direct_url}")
+                            webbrowser.open(direct_url)
+                        else:
+                            webbrowser.open(search_url)
+                except Exception as e:
+                    print(f"[VoiceAssistant] Autoplay scraper failed: {e}. Falling back to search page.")
+                    webbrowser.open(search_url)
+                
+                self.callbacks['set_system_state']("PLAYING_MUSIC")
+                return
+
+        has_stop = any(s in cleaned_text for s in ["stop", "pause", "turn off", "mute", "quiet", "halt", "shut up"])
+        if has_stop and (has_music_kw or "music" in cleaned_text or "song" in cleaned_text or "sound" in cleaned_text or "radio" in cleaned_text):
+            print("[VoiceAssistant] Flexible stop music command recognized.")
+            # Simulate media play/pause key to halt browser/audio stream
+            import ctypes
+            VK_MEDIA_PLAY_PAUSE = 0xB3
+            try:
+                ctypes.windll.user32.keybd_event(VK_MEDIA_PLAY_PAUSE, 0, 0, 0)
+                ctypes.windll.user32.keybd_event(VK_MEDIA_PLAY_PAUSE, 0, 2, 0)
+            except Exception as e:
+                print(f"[VoiceAssistant] Failed simulating media key: {e}")
+                
+            self.callbacks['set_system_state']("NORMAL")
+            self.callbacks['add_chat_log'](text, "Stop the music")
+            self.alert_manager.speak("Stopping the music. Keep your eyes on the road.")
+            self.callbacks['add_chat_log']("System", "Music stopped.")
+            return
+
+        # CONVERSATIONAL LOCAL SLM (Always Active - No Wake Word/Filters Required!)
+        # Route ANY general speech dynamically straight to our local Ollama custom model!
+        print(f"[Ollama Query] {text}")
+        reply = self.query_ollama_slm(text)
+        print(f"[SLM Reply] {reply}")
+        
+        # Check if Ollama returned a dynamic PLAY action tag (e.g. "[PLAY] paint it black")
+        if "[play]" in reply.lower():
+            match = re.search(r'\[play\]\s*(.*)', reply, re.IGNORECASE)
+            if match:
+                music_query = match.group(1).strip()
+                music_query = music_query.replace('"', '').replace('[', '').replace(']', '').strip()
+                
+                confirm_msg = f"Sure thing! Autoplay in progress for {music_query}."
+                self.callbacks['add_chat_log'](text, confirm_msg)
+                self.alert_manager.speak(confirm_msg)
+                
+                # Fetch the first search result from YouTube dynamically and play it directly!
+                search_url = f"https://www.youtube.com/results?search_query={urllib.parse.quote(music_query)}"
+                headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
+                try:
+                    req = urllib.request.Request(search_url, headers=headers)
+                    with urllib.request.urlopen(req, timeout=5) as res:
+                        html = res.read().decode('utf-8')
+                        # Search for video watch paths
+                        video_ids = re.findall(r'/watch\?v=([a-zA-Z0-9_-]{11})', html)
+                        if video_ids:
+                            first_video_id = video_ids[0]
+                            direct_url = f"https://www.youtube.com/watch?v={first_video_id}&autoplay=1"
+                            print(f"[VoiceAssistant] Auto-playing first matching YouTube video: {direct_url}")
+                            webbrowser.open(direct_url)
+                        else:
+                            webbrowser.open(search_url)
+                except Exception as e:
+                    print(f"[VoiceAssistant] Autoplay scraper failed: {e}. Falling back to search page.")
+                    webbrowser.open(search_url)
+                
+                self.callbacks['set_system_state']("PLAYING_MUSIC")
+                return
+
+        # Check if Ollama returned a dynamic STOP action tag (e.g. "[STOP]")
+        if "[stop]" in reply.lower():
+            match = re.search(r'\[stop\]\s*(.*)', reply, re.IGNORECASE)
+            clean_reply = match.group(1).strip() if match else "Stopping the music. Keep your eyes on the road!"
+            clean_reply = clean_reply.replace('[', '').replace(']', '').strip()
+            
+            print("[VoiceAssistant] Action STOP triggered dynamically by Ollama.")
+            # Simulate media play/pause key to stop the browser audio stream
+            import ctypes
+            VK_MEDIA_PLAY_PAUSE = 0xB3
+            try:
+                ctypes.windll.user32.keybd_event(VK_MEDIA_PLAY_PAUSE, 0, 0, 0)
+                ctypes.windll.user32.keybd_event(VK_MEDIA_PLAY_PAUSE, 0, 2, 0)
+            except Exception as e:
+                print(f"[VoiceAssistant] Failed simulating media key: {e}")
+                
+            self.callbacks['set_system_state']("NORMAL")
+            self.callbacks['add_chat_log'](text, clean_reply)
+            self.alert_manager.speak(clean_reply)
+            return
+                
+        # Check if Ollama returned a dynamic RESET action tag (e.g. "[RESET]")
+        if "[reset]" in reply.lower():
+            match = re.search(r'\[reset\]\s*(.*)', reply, re.IGNORECASE)
+            clean_reply = match.group(1).strip() if match else "System warnings cleared. Drive safely!"
+            clean_reply = clean_reply.replace('[', '').replace(']', '').strip()
+            
+            print("[VoiceAssistant] Action RESET triggered dynamically by Ollama.")
+            self.callbacks['reset_warnings']()
+            self.callbacks['add_chat_log'](text, clean_reply)
+            self.alert_manager.speak(clean_reply)
+            return
+
+        # General conversational response
+        self.callbacks['add_chat_log'](text, reply)
+        self.alert_manager.speak(reply)
+
+    def stop(self):
+        """Stops the assistant background thread."""
+        self.running = False
+
+
+# 6. SafeDrivingAssistant Core Engine & Orchestrator Coordinator
+
+class SafeDrivingAssistant:
+    def __init__(self):
+        print("[CoreEngine] Initializing Safe Driving Assistant...")
+        
+        # Initialize Audio Alert & Sound Synthesizer
+        self.alert_manager = AlertManager()
+        
+        # Initialize face_recognition Eye Landmark Processor
+        self.detector = EyeDetector()
+        
+        # Tracking states and timelines
+        self.consec_closed_frames = 0
+        self.eyes_closed_start_time = None
+        self.active_alert_level = 0  # 0: None, 1: Stay Focused, 2: Wake Up Loud
+        
+        # Rolling log of drowsiness timestamps to monitor frequency
+        self.drowsiness_events = collections.deque()
+        
+        # Keyboard reset helper
+        self.last_key_press = None
+        
+        # Setup conversational callbacks for our Voice Assistant & SLM
+        self.callbacks = {
+            'get_system_state': self.get_system_state,
+            'set_system_state': self.set_system_state,
+            'reset_warnings': self.reset_warnings,
+            'add_chat_log': self.add_chat_log
+        }
+        
+        # Bind callbacks back to Flask REST API endpoints
+        app.reset_callback = self.reset_warnings
+        app.play_music_callback = self.play_energetic_music
+        
+        # Initialize speech listener thread
+        self.assistant = VoiceAssistant(self.alert_manager, self.callbacks)
+        
+        # Boot Flask HUD Web Dashboard in the background
+        start_server_async()
+
+    # Coordinator Callback Handlers
+
+    def get_system_state(self):
+        """Thread-safe state getter for the Voice Assistant."""
+        with dashboard_state.lock:
+            return dashboard_state.state
+
+    def set_system_state(self, new_state):
+        """Thread-safe state setter for the Voice Assistant."""
+        with dashboard_state.lock:
+            dashboard_state.state = new_state
+            if new_state == "NORMAL":
+                dashboard_state.alert_message = ""
+            elif new_state == "WAITING_REST_RESPONSE":
+                dashboard_state.alert_message = "ADVISING REST BREAK"
+            elif new_state == "WAITING_SONG_RESPONSE":
+                dashboard_state.alert_message = "OFFERING ENERGETIC MUSIC"
+            elif new_state == "PLAYING_MUSIC":
+                dashboard_state.alert_message = "PLAYING HIGH ENERGY BEATS"
+
+    def reset_warnings(self):
+        """Complete reset of all active alarms, timers, and warning metrics."""
+        print("[CoreEngine] Performing comprehensive system alert reset.")
+        with dashboard_state.lock:
+            dashboard_state.state = "NORMAL"
+            dashboard_state.alert_message = ""
+            dashboard_state.drowsiness_count = 0
+        self.consec_closed_frames = 0
+        self.eyes_closed_start_time = None
+        self.active_alert_level = 0
+        self.drowsiness_events.clear()
+        
+        # Enqueue a log message
+        self.add_chat_log("System", "System alerts and warnings reset to NORMAL.")
+
+    def add_chat_log(self, user_query, slm_reply=""):
+        """Pushes voice transcripts to the dashboard log log history."""
+        with dashboard_state.lock:
+            if user_query == "System":
+                dashboard_state.chat_history.append({
+                    "speaker": "System",
+                    "message": slm_reply
+                })
+            else:
+                dashboard_state.chat_history.append({
+                    "speaker": "Driver",
+                    "query": user_query,
+                    "message": slm_reply
+                })
+
+    def play_energetic_music(self):
+        """Orchestrator hook to trigger the energetic music sequence."""
+        self.set_system_state("PLAYING_MUSIC")
+        self.alert_manager.play_energetic_music()
+        self.add_chat_log("System", "Energetic synthwave music started. Stay alert!")
+
+    # Core Drowsiness Evaluation & Loop
+
+    def run(self):
+        """Main camera acquisition loop that drives the safe assistant."""
+        print("[CoreEngine] Accessing camera stream...")
+        cap = cv2.VideoCapture(CAMERA_ID)
+        
+        # Configure video dimension overrides from settings
+        cap.set(cv2.CAP_PROP_FRAME_WIDTH, FRAME_WIDTH)
+        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, FRAME_HEIGHT)
+        
+        if not cap.isOpened():
+            print("[CoreEngine] FATAL: Could not access web camera.")
+            return
+
+        print("[CoreEngine] Camera stream operational. System fully active.")
+        print("[CoreEngine] Press 'q' in CV window or click Dashboard Reset to quit.")
+        
+        prev_time = time.time()
+        
+        try:
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    time.sleep(0.01)
+                    continue
+
+                # Mirror frame for intuitive pilot HUD overlay
+                frame = cv2.flip(frame, 1)
+                
+                # Check if tracking is active (controlled from Dashboard)
+                with dashboard_state.lock:
+                    active = dashboard_state.detection_active
+                    
+                if active:
+                    # Calculate EAR and overlay glow contours on frame
+                    ear, landmarks, processed_frame = self.detector.process_frame(frame)
+                else:
+                    processed_frame = frame.copy()
+                    cv2.putText(processed_frame, "TRACKING PAUSED", (50, 50), 
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 165, 255), 2)
+                    ear = None
+
+                current_time = time.time()
+                
+                # Calculate processing frame rate (FPS)
+                fps = int(1.0 / (current_time - prev_time))
+                prev_time = current_time
+
+                # Drowsiness Logic Decision Engine
+
+                if ear is not None and active:
+                    if ear < EAR_THRESHOLD:
+                        self.consec_closed_frames += 1
+                        
+                        # Once consecutive frames pass noise filter, start duration timer
+                        if self.consec_closed_frames >= EAR_CONSEC_FRAMES:
+                            if self.eyes_closed_start_time is None:
+                                self.eyes_closed_start_time = current_time
+                            else:
+                                closed_duration = current_time - self.eyes_closed_start_time
+                                
+                                # LEVEL 1: Eyes Closed 3-5 seconds
+                                if ALERT_LEVEL1_MIN <= closed_duration < ALERT_LEVEL1_MAX:
+                                    if self.active_alert_level < 1:
+                                        self.active_alert_level = 1
+                                        self.set_system_state("CLOSED_3S")
+                                        self.alert_manager.trigger_level1()
+                                        
+                                        # Record timestamp to sliding frequency tracker
+                                        self.drowsiness_events.append(current_time)
+                                        with dashboard_state.lock:
+                                            dashboard_state.drowsiness_count += 1
+                                            
+                                        self.add_chat_log("System", "WARNING: Eyes closed for 3 seconds! Stay focused!")
+                                
+                                # LEVEL 2: Eyes Closed > 5 seconds (Louder Warning!)
+                                elif closed_duration >= ALERT_LEVEL2_MIN:
+                                    if self.active_alert_level < 2:
+                                        self.active_alert_level = 2
+                                        self.set_system_state("CLOSED_5S")
+                                        self.alert_manager.trigger_level2()
+                                        
+                                        # Record second timestamp
+                                        self.drowsiness_events.append(current_time)
+                                        with dashboard_state.lock:
+                                            dashboard_state.drowsiness_count += 1
+                                            
+                                        self.add_chat_log("System", "CRITICAL ALARM: Eyes closed for 5+ seconds! WAKE UP!")
+                    else:
+                        # Eyes are open! Reset filters and check for Level 3 Advisory escalation
+                        self.consec_closed_frames = 0
+                        
+                        if self.eyes_closed_start_time is not None:
+                            self.eyes_closed_start_time = None
+                            
+                            while self.drowsiness_events and (current_time - self.drowsiness_events[0] > FREQUENT_DROWSY_WINDOW):
+                                self.drowsiness_events.popleft()
+                                
+                            # LEVEL 3: Frequent Drowsiness check (if closed events occur >= limit in last 60s)
+                            if len(self.drowsiness_events) >= FREQUENT_DROWSY_LIMIT:
+                                print(f"[CoreEngine] Frequent drowsiness detected ({len(self.drowsiness_events)} events in 60s). Escalating to Level 3.")
+                                self.set_system_state("WAITING_REST_RESPONSE")
+                                self.alert_manager.trigger_level3_advisory()
+                                self.add_chat_log("System", "FREQUENT DROWSINESS DETECTED. Prompting driver to pull over.")
+                            else:
+                                # Normal recovery (driver had a brief blink/close and is now normal)
+                                current_state = self.get_system_state()
+                                if current_state not in ["WAITING_REST_RESPONSE", "WAITING_SONG_RESPONSE"]:
+                                    self.set_system_state("NORMAL")
+                                    self.active_alert_level = 0
+                else:
+                    self.consec_closed_frames = 0
+                    self.eyes_closed_start_time = None
+
+                # Update Global Telemetry Buffer for Flask Server
+
+                with dashboard_state.lock:
+                    dashboard_state.latest_frame = processed_frame.copy()
+                    if ear is not None:
+                        dashboard_state.ear = ear
+                    else:
+                        dashboard_state.ear = 0.30  # Default baseline when no face present
+                    dashboard_state.fps = fps
+
+                # OpenCV display output fallback (allows running headless or with double screens)
+                cv2.imshow("DriveSafe HUD AI Console", processed_frame)
+                
+                # Check for keyboard inputs on CV Window ('q' to quit, 'r' to reset)
+                key = cv2.waitKey(1) & 0xFF
+                if key == ord('q') or key == 27:  # ESC or Q
+                    print("[CoreEngine] Exit key received. Terminating system.")
+                    break
+                elif key == ord('r'):
+                    self.reset_warnings()
+
+        except KeyboardInterrupt:
+            print("[CoreEngine] Keyboard interrupt. Shutting down.")
+        finally:
+            print("[CoreEngine] Releasing resources...")
+            cap.release()
+            cv2.destroyAllWindows()
+            self.assistant.stop()
+            sys.exit(0)
+
+if __name__ == "__main__":
+    assistant_app = SafeDrivingAssistant()
+    assistant_app.run()

requirements.txt

@@ -0,0 +1,10 @@
+opencv-python>=4.8.0
+pyttsx3>=2.90
+SpeechRecognition>=3.10.0
+pyaudio>=0.2.14
+pygame>=2.5.0
+numpy>=1.24.0
+scipy>=1.11.0
+soundfile>=0.12.0
+flask>=3.0.0
+face_recognition @ git+https://github.com/lovnishverma/face_recognition.git

static/js/app.js

@@ -0,0 +1,288 @@
+// ==============================================================================
+//  DriveSafe HUD Dashboard JavaScript
+//  Establishes real-time EventSource connection, draws Chart.js EKG, and manages HUD state.
+// ==============================================================================
+
+let earChart;
+const maxChartPoints = 40;
+let chartData = Array(maxChartPoints).fill(0.3);
+let chartLabels = Array(maxChartPoints).fill("");
+let renderedChatLogsCount = 0;
+
+// --- Initialize Chart.js on DOM Load ---
+document.addEventListener("DOMContentLoaded", () => {
+    const ctx = document.getElementById('earChart').getContext('2d');
+    
+    // Create futuristic neon line chart
+    earChart = new Chart(ctx, {
+        type: 'line',
+        data: {
+            labels: chartLabels,
+            datasets: [{
+                label: 'Eye Aspect Ratio (EAR)',
+                data: chartData,
+                borderColor: '#00bfff',
+                borderWidth: 2,
+                pointRadius: 0,
+                fill: true,
+                backgroundColor: 'rgba(0, 191, 255, 0.05)',
+                tension: 0.4
+            }]
+        },
+        options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+                legend: { display: false }
+            },
+            scales: {
+                x: { display: false },
+                y: {
+                    min: 0.0,
+                    max: 0.45,
+                    grid: { color: 'rgba(255, 255, 255, 0.03)' },
+                    ticks: {
+                        color: '#64748b',
+                        font: { family: 'Share Tech Mono', size: 10 }
+                    }
+                }
+            },
+            animation: { duration: 0 } // Disable default anims for absolute high-speed rendering
+        }
+    });
+
+    // Initialize Telemetry EventSource listener
+    initTelemetry();
+});
+
+// --- Server-Sent Events (SSE) Telemetry Listener ---
+function initTelemetry() {
+    const sse = new EventSource('/telemetry');
+    
+    sse.onmessage = (event) => {
+        const data = JSON.parse(event.data);
+        
+        // 1. Update Core Readouts
+        updateMetrics(data);
+        
+        // 2. Shift EAR Graph Data
+        updateChart(data.ear);
+        
+        // 3. Update Conversation Chat Logs
+        updateChat(data.chat_history);
+        
+        // 4. Update HUD panel glowing states
+        updateStateOverlays(data.state, data.alert_message);
+    };
+    
+    sse.onerror = (err) => {
+        console.error("SSE connection dropped:", err);
+    };
+}
+
+// --- Update Circular Gauge & Numeric Metrics ---
+function updateMetrics(data) {
+    // Current numeric readout
+    document.getElementById("ear-val").innerText = data.ear.toFixed(2);
+    
+    // Circular radial progress math
+    const gauge = document.getElementById("ear-gauge");
+    const radius = gauge.r.baseVal.value;
+    const circumference = 2 * Math.PI * radius;
+    
+    // EAR bounds are normally between 0.10 (fully closed) and 0.35 (wide open)
+    // Normalize EAR to 0% - 100% range
+    let percentage = (data.ear - 0.10) / (0.35 - 0.10);
+    percentage = Math.max(0, Math.min(1, percentage)); // Clamp between 0 and 1
+    
+    const offset = circumference - (percentage * circumference);
+    gauge.style.strokeDashoffset = offset;
+    
+    // Change gauge color relative to EAR thresholds
+    const warnThreshold = 0.23;
+    const closedThreshold = 0.20;
+    
+    if (data.ear <= closedThreshold) {
+        gauge.style.stroke = "var(--danger-color)";
+    } else if (data.ear <= warnThreshold) {
+        gauge.style.stroke = "var(--warn-color)";
+    } else {
+        gauge.style.stroke = "var(--safe-color)";
+    }
+    
+    // Update Drowsiness Count
+    const countElement = document.getElementById("drowsiness-count");
+    countElement.innerText = data.drowsiness_count;
+    if (data.drowsiness_count > 0) {
+        countElement.style.color = "var(--danger-color)";
+        countElement.style.textShadow = "0 0 10px rgba(255, 40, 80, 0.4)";
+    } else {
+        countElement.style.color = "var(--safe-color)";
+        countElement.style.textShadow = "none";
+    }
+    
+    // Update Engine FPS
+    document.getElementById("engine-fps").innerText = `${data.fps} FPS`;
+    
+    // Update Tracking active button toggle
+    const trackingBtn = document.getElementById("toggle-tracking-btn");
+    const label = trackingBtn.querySelector("span");
+    if (data.detection_active) {
+        trackingBtn.classList.add("active");
+        label.innerText = "ACTIVE TRACKING";
+    } else {
+        trackingBtn.classList.remove("active");
+        label.innerText = "TRACKING PAUSED";
+    }
+}
+
+// --- EKG EAR Waveform Chart Shifter ---
+function updateChart(newEar) {
+    chartData.push(newEar);
+    chartData.shift();
+    
+    // Swap graph colors based on EAR values
+    if (newEar < 0.20) {
+        earChart.data.datasets[0].borderColor = "#ff2850";
+        earChart.data.datasets[0].backgroundColor = "rgba(255, 40, 80, 0.05)";
+    } else if (newEar < 0.23) {
+        earChart.data.datasets[0].borderColor = "#ffaa00";
+        earChart.data.datasets[0].backgroundColor = "rgba(255, 170, 0, 0.05)";
+    } else {
+        earChart.data.datasets[0].borderColor = "#00ff80";
+        earChart.data.datasets[0].backgroundColor = "rgba(0, 255, 128, 0.05)";
+    }
+    
+    earChart.update();
+}
+
+// --- Dynamic Conversational Chat Logs renderer ---
+function updateChat(history) {
+    if (history.length === renderedChatLogsCount) return;
+    
+    const chatBox = document.getElementById("chat-box");
+    
+    // Render only new logs added since last pass
+    for (let i = renderedChatLogsCount; i < history.length; i++) {
+        const log = history[i];
+        
+        // System logs represent state announcements
+        if (log.speaker === "System") {
+            const systemDiv = document.createElement("div");
+            systemDiv.className = "chat-bubble system-bubble";
+            systemDiv.innerText = log.message;
+            chatBox.appendChild(systemDiv);
+        } else {
+            // User query
+            if (log.query) {
+                const userDiv = document.createElement("div");
+                userDiv.className = "chat-bubble driver-bubble";
+                userDiv.innerHTML = `<span class="bubble-label">Driver</span>${escapeHTML(log.query)}`;
+                chatBox.appendChild(userDiv);
+            }
+            
+            // AI response
+            if (log.message) {
+                const aiDiv = document.createElement("div");
+                aiDiv.className = "chat-bubble slm-bubble";
+                aiDiv.innerHTML = `<span class="bubble-label">DriveSafe SLM</span>${escapeHTML(log.message)}`;
+                chatBox.appendChild(aiDiv);
+            }
+        }
+    }
+    
+    renderedChatLogsCount = history.length;
+    
+    // Auto-scroll chat box down with a short delay for fluid rendering
+    setTimeout(() => {
+        chatBox.scrollTop = chatBox.scrollHeight;
+    }, 50);
+}
+
+// --- Toggle HUD Glowing Cockpit States ---
+function updateStateOverlays(state, alertMsg) {
+    const mainPanel = document.getElementById("main-panel");
+    const badge = document.getElementById("hud-state-badge");
+    const slmIndicator = document.getElementById("slm-indicator");
+    
+    // Clean current state classes
+    mainPanel.className = "glass-panel video-panel";
+    
+    if (state === "NORMAL") {
+        mainPanel.classList.add("state-normal");
+        badge.innerText = alertMsg ? alertMsg : "NORMAL";
+        badge.style.borderColor = "var(--safe-color)";
+        badge.style.color = "var(--safe-color)";
+        badge.style.boxShadow = "0 0 10px rgba(0, 255, 128, 0.2)";
+        slmIndicator.innerText = "SLM STANDBY";
+        slmIndicator.style.color = "var(--safe-color)";
+    } 
+    else if (state === "CLOSED_3S") {
+        mainPanel.classList.add("state-warn");
+        badge.innerText = alertMsg ? alertMsg : "EYES CLOSED (3-5s)";
+        badge.style.borderColor = "var(--warn-color)";
+        badge.style.color = "var(--warn-color)";
+        badge.style.boxShadow = "0 0 15px rgba(255, 170, 0, 0.3)";
+    } 
+    else if (state === "CLOSED_5S" || state === "WAITING_REST_RESPONSE" || state === "WAITING_SONG_RESPONSE") {
+        mainPanel.classList.add("state-danger");
+        badge.innerText = alertMsg ? alertMsg : "CRITICAL WARNING";
+        badge.style.borderColor = "var(--danger-color)";
+        badge.style.color = "var(--danger-color)";
+        badge.style.boxShadow = "0 0 25px rgba(255, 40, 80, 0.5)";
+        
+        if (state.startsWith("WAITING")) {
+            slmIndicator.innerText = "SLM ACTIVE DIALOGUE";
+            slmIndicator.style.color = "var(--accent-color)";
+        }
+    }
+    else if (state === "PLAYING_MUSIC") {
+        mainPanel.classList.add("state-normal");
+        badge.innerText = "BEATS PLAYING";
+        badge.style.borderColor = "var(--accent-color)";
+        badge.style.color = "var(--accent-color)";
+        badge.style.boxShadow = "0 0 10px rgba(0, 191, 255, 0.2)";
+    }
+}
+
+// --- Control Desk AJAX REST Bridge ---
+
+function toggleTracking() {
+    fetch('/api/toggle_detection', { method: 'POST' })
+        .then(response => response.json())
+        .then(data => {
+            console.log("Tracking toggled, active state:", data.detection_active);
+        })
+        .catch(err => console.error("Error toggling tracking:", err));
+}
+
+function triggerReset() {
+    fetch('/api/reset', { method: 'POST' })
+        .then(response => response.json())
+        .then(data => {
+            console.log("System reset:", data.message);
+        })
+        .catch(err => console.error("Error triggering reset:", err));
+}
+
+function triggerMusic() {
+    fetch('/api/trigger_music', { method: 'POST' })
+        .then(response => response.json())
+        .then(data => {
+            console.log("Music play request sent:", data.message);
+        })
+        .catch(err => console.error("Error playing energetic beats:", err));
+}
+
+// --- Helper Functions ---
+function escapeHTML(str) {
+    return str.replace(/[&<>'"]/g, 
+        tag => ({
+            '&': '&amp;',
+            '<': '&lt;',
+            '>': '&gt;',
+            "'": '&#39;',
+            '"': '&quot;'
+        }[tag] || tag)
+    );
+}

templates/index.html

@@ -0,0 +1,665 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DriveSafe — AI Safety HUD & Conversational SLM</title>
+    <!-- Google Fonts for High-Tech Dashboard Aesthetic -->
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;600;800&family=Share+Tech+Mono&display=swap" rel="stylesheet">
+    <!-- Chart.js for High-Performance EKG Graph -->
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        :root {
+            --bg-color: #08090e;
+            --panel-bg: rgba(15, 18, 28, 0.7);
+            --border-glow: rgba(0, 255, 128, 0.15);
+            --safe-color: #00ff80;
+            --warn-color: #ffaa00;
+            --danger-color: #ff2850;
+            --accent-color: #00bfff;
+            --text-color: #e2e8f0;
+            --text-muted: #64748b;
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+            font-family: 'Outfit', sans-serif;
+            -webkit-font-smoothing: antialiased;
+        }
+
+        body {
+            background-color: var(--bg-color);
+            background-image: 
+                radial-gradient(at 0% 0%, rgba(0, 191, 255, 0.05) 0px, transparent 50%),
+                radial-gradient(at 100% 0%, rgba(0, 255, 128, 0.05) 0px, transparent 50%),
+                radial-gradient(at 50% 100%, rgba(255, 40, 80, 0.03) 0px, transparent 50%);
+            color: var(--text-color);
+            min-height: 100vh;
+            overflow-x: hidden;
+            display: flex;
+            flex-direction: column;
+        }
+
+        /* --- Header --- */
+        header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 20px 40px;
+            background: rgba(8, 9, 14, 0.85);
+            backdrop-filter: blur(12px);
+            border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+            position: sticky;
+            top: 0;
+            z-index: 100;
+        }
+
+        .logo-section {
+            display: flex;
+            align-items: center;
+            gap: 15px;
+        }
+
+        .logo-section h1 {
+            font-size: 24px;
+            font-weight: 800;
+            letter-spacing: 2px;
+            background: linear-gradient(to right, #00ff80, #00bfff);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+
+        .logo-section span {
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 11px;
+            background: rgba(0, 191, 255, 0.1);
+            color: var(--accent-color);
+            padding: 2px 8px;
+            border: 1px solid rgba(0, 191, 255, 0.2);
+            border-radius: 4px;
+        }
+
+        .connection-status {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 13px;
+            font-weight: 600;
+            color: var(--safe-color);
+        }
+
+        .pulse-dot {
+            width: 8px;
+            height: 8px;
+            background-color: var(--safe-color);
+            border-radius: 50%;
+            box-shadow: 0 0 10px var(--safe-color);
+            animation: pulse 1.5s infinite;
+        }
+
+        /* --- Main Dashboard Container --- */
+        .dashboard-container {
+            display: grid;
+            grid-template-columns: 1.1fr 0.9fr;
+            gap: 30px;
+            padding: 30px 40px;
+            flex-grow: 1;
+            max-width: 1800px;
+            margin: 0 auto;
+            width: 100%;
+        }
+
+        .glass-panel {
+            background: var(--panel-bg);
+            backdrop-filter: blur(16px);
+            border: 1px solid rgba(255, 255, 255, 0.05);
+            border-radius: 20px;
+            padding: 24px;
+            box-shadow: 0 12px 32px rgba(0, 0, 0, 0.4);
+            transition: all 0.4s cubic-bezier(0.16, 1, 0.3, 1);
+            position: relative;
+            overflow: hidden;
+        }
+
+        .glass-panel::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 4px;
+            background: linear-gradient(90deg, transparent, var(--border-glow), transparent);
+            transition: all 0.4s ease;
+        }
+
+        /* --- LEFT COLUMN: CAMERA & VISUAL HUD --- */
+        .left-column {
+            display: flex;
+            flex-direction: column;
+            gap: 30px;
+        }
+
+        .video-panel {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .video-container {
+            width: 100%;
+            aspect-ratio: 4/3;
+            background-color: #050608;
+            border-radius: 12px;
+            overflow: hidden;
+            border: 1px solid rgba(255, 255, 255, 0.08);
+            position: relative;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .video-stream {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+        }
+
+        .video-placeholder {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 15px;
+            color: var(--text-muted);
+            text-align: center;
+        }
+
+        .video-placeholder svg {
+            width: 60px;
+            height: 60px;
+            stroke: var(--text-muted);
+            animation: rotate-sync 4s linear infinite;
+        }
+
+        .hud-overlay-badge {
+            position: absolute;
+            top: 15px;
+            right: 15px;
+            background: rgba(0, 0, 0, 0.7);
+            border: 1px solid var(--safe-color);
+            padding: 4px 12px;
+            border-radius: 6px;
+            font-size: 12px;
+            font-weight: 600;
+            color: var(--safe-color);
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            box-shadow: 0 0 10px rgba(0, 255, 128, 0.2);
+            transition: all 0.3s ease;
+        }
+
+        /* --- Indicators Panel --- */
+        .indicators-grid {
+            display: grid;
+            grid-template-columns: repeat(3, 1fr);
+            gap: 20px;
+        }
+
+        .metric-card {
+            background: rgba(255, 255, 255, 0.02);
+            border: 1px solid rgba(255, 255, 255, 0.04);
+            border-radius: 14px;
+            padding: 18px;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            text-align: center;
+            position: relative;
+        }
+
+        .metric-title {
+            font-size: 12px;
+            color: var(--text-muted);
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            margin-bottom: 8px;
+        }
+
+        .metric-value {
+            font-size: 32px;
+            font-weight: 800;
+            font-family: 'Share Tech Mono', monospace;
+        }
+
+        /* Gauge Meter styling */
+        .gauge-container {
+            width: 100px;
+            height: 100px;
+            position: relative;
+            margin-bottom: 5px;
+        }
+
+        .radial-gauge {
+            width: 100%;
+            height: 100%;
+            transform: rotate(-90deg);
+        }
+
+        .gauge-circle {
+            fill: none;
+            stroke-width: 4;
+            stroke: rgba(255, 255, 255, 0.05);
+        }
+
+        .gauge-bar {
+            fill: none;
+            stroke-width: 6;
+            stroke-dasharray: 251.2;
+            stroke-dashoffset: 251.2;
+            stroke: var(--safe-color);
+            stroke-linecap: round;
+            transition: stroke-dashoffset 0.1s ease, stroke 0.3s ease;
+        }
+
+        .gauge-text {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            font-size: 20px;
+            font-weight: 800;
+            font-family: 'Share Tech Mono', monospace;
+            color: var(--text-color);
+        }
+
+        /* --- RIGHT COLUMN: SLM TERMINAL & DIAGNOSTICS --- */
+        .right-column {
+            display: flex;
+            flex-direction: column;
+            gap: 30px;
+        }
+
+        /* Chart Panel */
+        .chart-container {
+            height: 180px;
+            width: 100%;
+        }
+
+        /* SLM Conversation terminal */
+        .terminal-panel {
+            display: flex;
+            flex-direction: column;
+            height: 380px;
+        }
+
+        .terminal-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+            padding-bottom: 12px;
+            margin-bottom: 15px;
+        }
+
+        .terminal-title {
+            font-size: 14px;
+            font-weight: 700;
+            letter-spacing: 1px;
+            text-transform: uppercase;
+            color: var(--accent-color);
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .terminal-body {
+            flex-grow: 1;
+            overflow-y: auto;
+            display: flex;
+            flex-direction: column;
+            gap: 15px;
+            padding-right: 5px;
+            font-family: 'Outfit', sans-serif;
+            scroll-behavior: smooth;
+        }
+
+        /* Scrollbar custom styling */
+        .terminal-body::-webkit-scrollbar {
+            width: 4px;
+        }
+        .terminal-body::-webkit-scrollbar-thumb {
+            background: rgba(255, 255, 255, 0.1);
+            border-radius: 2px;
+        }
+
+        /* Chat bubbles */
+        .chat-bubble {
+            max-width: 80%;
+            padding: 12px 16px;
+            border-radius: 12px;
+            font-size: 14px;
+            line-height: 1.5;
+            animation: slide-up 0.3s ease;
+        }
+
+        .driver-bubble {
+            align-self: flex-end;
+            background: rgba(0, 191, 255, 0.08);
+            border: 1px solid rgba(0, 191, 255, 0.15);
+            color: #dbeafe;
+            border-bottom-right-radius: 2px;
+        }
+
+        .slm-bubble {
+            align-self: flex-start;
+            background: rgba(0, 255, 128, 0.05);
+            border: 1px solid rgba(0, 255, 128, 0.12);
+            color: #dcfce7;
+            border-bottom-left-radius: 2px;
+        }
+
+        .system-bubble {
+            align-self: center;
+            background: rgba(255, 40, 80, 0.08);
+            border: 1px solid rgba(255, 40, 80, 0.15);
+            color: #ffe4e6;
+            max-width: 90%;
+            font-family: 'Share Tech Mono', monospace;
+            font-size: 12px;
+            text-transform: uppercase;
+            text-align: center;
+            border-radius: 6px;
+            padding: 6px 12px;
+        }
+
+        .bubble-label {
+            font-size: 10px;
+            font-weight: 800;
+            letter-spacing: 1px;
+            text-transform: uppercase;
+            margin-bottom: 4px;
+            display: block;
+        }
+        
+        .driver-bubble .bubble-label {
+            color: var(--accent-color);
+        }
+
+        .slm-bubble .bubble-label {
+            color: var(--safe-color);
+        }
+
+        /* --- Control Desk Buttons --- */
+        .control-desk {
+            display: grid;
+            grid-template-columns: repeat(3, 1fr);
+            gap: 15px;
+        }
+
+        .cyber-btn {
+            background: rgba(255, 255, 255, 0.02);
+            border: 1px solid rgba(255, 255, 255, 0.06);
+            border-radius: 10px;
+            padding: 12px;
+            font-size: 13px;
+            font-weight: 600;
+            color: var(--text-color);
+            cursor: pointer;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            gap: 6px;
+            transition: all 0.2s ease;
+        }
+
+        .cyber-btn:hover {
+            background: rgba(255, 255, 255, 0.06);
+            border-color: rgba(255, 255, 255, 0.15);
+            transform: translateY(-2px);
+        }
+
+        .cyber-btn:active {
+            transform: translateY(0);
+        }
+
+        .cyber-btn svg {
+            width: 20px;
+            height: 20px;
+            stroke: var(--text-color);
+            transition: all 0.2s ease;
+        }
+
+        .cyber-btn.active {
+            background: rgba(0, 255, 128, 0.08);
+            border-color: var(--safe-color);
+            color: var(--safe-color);
+        }
+
+        .cyber-btn.active svg {
+            stroke: var(--safe-color);
+        }
+
+        .cyber-btn.danger {
+            background: rgba(255, 40, 80, 0.05);
+            border-color: rgba(255, 40, 80, 0.2);
+        }
+
+        .cyber-btn.danger:hover {
+            background: rgba(255, 40, 80, 0.12);
+            border-color: var(--danger-color);
+            color: var(--danger-color);
+        }
+        
+        .cyber-btn.danger:hover svg {
+            stroke: var(--danger-color);
+        }
+
+        /* --- DYNAMIC STATE OVERLAYS (WARNING SHADOWS) --- */
+        .glass-panel.state-normal::before {
+            background: linear-gradient(90deg, transparent, var(--safe-color), transparent);
+        }
+        
+        .glass-panel.state-warn::before {
+            background: linear-gradient(90deg, transparent, var(--warn-color), transparent);
+        }
+        .glass-panel.state-warn {
+            border-color: rgba(255, 170, 0, 0.15);
+            box-shadow: 0 0 20px rgba(255, 170, 0, 0.1);
+        }
+
+        .glass-panel.state-danger::before {
+            background: linear-gradient(90deg, transparent, var(--danger-color), transparent);
+        }
+        .glass-panel.state-danger {
+            border-color: rgba(255, 40, 80, 0.3);
+            box-shadow: 0 0 30px rgba(255, 40, 80, 0.2);
+            animation: pulse-border 1.5s infinite;
+        }
+
+        /* --- Animations --- */
+        @keyframes pulse {
+            0% { transform: scale(1); opacity: 1; box-shadow: 0 0 10px var(--safe-color); }
+            50% { transform: scale(1.1); opacity: 0.7; box-shadow: 0 0 20px var(--safe-color); }
+            100% { transform: scale(1); opacity: 1; box-shadow: 0 0 10px var(--safe-color); }
+        }
+
+        @keyframes pulse-border {
+            0% { border-color: rgba(255, 40, 80, 0.2); }
+            50% { border-color: rgba(255, 40, 80, 0.6); }
+            100% { border-color: rgba(255, 40, 80, 0.2); }
+        }
+
+        @keyframes rotate-sync {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        @keyframes slide-up {
+            0% { transform: translateY(10px); opacity: 0; }
+            100% { transform: translateY(0); opacity: 1; }
+        }
+
+        /* Responsive */
+        @media (max-width: 1200px) {
+            .dashboard-container {
+                grid-template-columns: 1fr;
+                padding: 20px;
+            }
+        }
+    </style>
+</head>
+<body>
+
+    <header>
+        <div class="logo-section">
+            <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="url(#logo-grad)" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+                <rect x="3" y="11" width="18" height="11" rx="2" ry="2"></rect>
+                <path d="M7 11V7a5 5 0 0 1 10 0v4"></path>
+            </svg>
+            <svg style="width:0;height:0;position:absolute">
+                <linearGradient id="logo-grad" x1="0%" y1="0%" x2="100%" y2="0%">
+                    <stop offset="0%" stop-color="#00ff80"/>
+                    <stop offset="100%" stop-color="#00bfff"/>
+                </linearGradient>
+            </svg>
+            <h1>DRIVESAFE</h1>
+            <span>LOCAL SLM V1.0</span>
+        </div>
+        <div class="connection-status">
+            <div class="pulse-dot"></div>
+            HUD SYSTEM RUNNING
+        </div>
+    </header>
+
+    <div class="dashboard-container">
+        
+        <!-- LEFT COLUMN: VIDEO FEED & METRIC READOUTS -->
+        <div class="left-column">
+            
+            <!-- Video feed Panel -->
+            <div class="glass-panel video-panel state-normal" id="main-panel">
+                <div class="video-container">
+                    <img src="/video_feed" class="video-stream" id="video-feed" onerror="showPlaceholder()">
+                    <div class="hud-overlay-badge" id="hud-state-badge">NORMAL</div>
+                    
+                    <div class="video-placeholder" id="video-placeholder" style="display:none;">
+                        <svg viewBox="0 0 24 24" fill="none" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+                            <line x1="1" y1="1" x2="23" y2="23"></line>
+                            <path d="M21 21H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3m3-3h6l2 3h4a2 2 0 0 1 2 2v9.34"></path>
+                            <path d="M10.02 4.35L8.06 6H3"></path>
+                            <circle cx="12" cy="13" r="4"></circle>
+                        </svg>
+                        <p>Awaiting Safe Driving Camera Stream...</p>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Core Indicators grid -->
+            <div class="indicators-grid">
+                
+                <!-- Eye Aspect Ratio (EAR) Gauge -->
+                <div class="metric-card">
+                    <div class="metric-title">Eye Aspect Ratio</div>
+                    <div class="gauge-container">
+                        <svg class="radial-gauge" viewBox="0 0 100 100">
+                            <circle class="gauge-circle" cx="50" cy="50" r="40"></circle>
+                            <circle class="gauge-bar" id="ear-gauge" cx="50" cy="50" r="40"></circle>
+                        </svg>
+                        <div class="gauge-text" id="ear-val">0.00</div>
+                    </div>
+                </div>
+                
+                <!-- Event counter -->
+                <div class="metric-card">
+                    <div class="metric-title">Drowsy Detections</div>
+                    <div class="metric-value" id="drowsiness-count" style="color: var(--safe-color);">0</div>
+                </div>
+                
+                <!-- System FPS -->
+                <div class="metric-card">
+                    <div class="metric-title">Core Engine Speed</div>
+                    <div class="metric-value" id="engine-fps" style="color: var(--accent-color);">0 FPS</div>
+                </div>
+                
+            </div>
+            
+        </div>
+
+        <!-- RIGHT COLUMN: CHAT LOG, CHART & DESK CONTROLS -->
+        <div class="right-column">
+            
+            <!-- Real-time Line Graph Panel -->
+            <div class="glass-panel">
+                <div class="metric-title" style="margin-bottom:12px;">Active EKG Eye Waveform</div>
+                <div class="chart-container">
+                    <canvas id="earChart"></canvas>
+                </div>
+            </div>
+            
+            <!-- DriveSafe Conversational Terminal -->
+            <div class="glass-panel terminal-panel">
+                <div class="terminal-header">
+                    <div class="terminal-title">
+                        <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+                        </svg>
+                        COGNITIVE VOICE ASSISTANT
+                    </div>
+                    <span id="slm-indicator" style="font-size:10px; font-family:'Share Tech Mono', monospace; color: var(--safe-color);">SLM ONLINE</span>
+                </div>
+                
+                <div class="terminal-body" id="chat-box">
+                    <div class="chat-bubble slm-bubble">
+                        <span class="bubble-label">DriveSafe SLM</span>
+                        Hello driver! I am active. Let's drive safely today. Ask me any question, or say "play music"!
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Cyber Control Desk -->
+            <div class="control-desk">
+                <button class="cyber-btn active" id="toggle-tracking-btn" onclick="toggleTracking()">
+                    <svg viewBox="0 0 24 24" fill="none" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                        <path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"></path>
+                        <circle cx="12" cy="12" r="3"></circle>
+                    </svg>
+                    <span>ACTIVE TRACKING</span>
+                </button>
+                
+                <button class="cyber-btn" onclick="triggerReset()">
+                    <svg viewBox="0 0 24 24" fill="none" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                        <path d="M21.5 2v6h-6M21.34 15.57a10 10 0 1 1-.57-8.38l5.67-5.67"></path>
+                    </svg>
+                    <span>SYSTEM RESET</span>
+                </button>
+                
+                <button class="cyber-btn danger" onclick="triggerMusic()">
+                    <svg viewBox="0 0 24 24" fill="none" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                        <path d="M9 18V5l12-2v13"></path>
+                        <circle cx="6" cy="18" r="3"></circle>
+                        <circle cx="18" cy="16" r="3"></circle>
+                    </svg>
+                    <span>PLAY BEATS</span>
+                </button>
+            </div>
+            
+        </div>
+
+    </div>
+
+    <!-- Script file mapping -->
+    <script src="/static/js/app.js"></script>
+    <script>
+        function showPlaceholder() {
+            document.getElementById('video-feed').style.display = 'none';
+            document.getElementById('video-placeholder').style.display = 'flex';
+        }
+    </script>
+</body>
+</html>