Upload 8 files

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 src/shape_predictor_68_face_landmarks.dat filter=lfs diff=lfs merge=lfs -text
+shape_predictor_68_face_landmarks.dat filter=lfs diff=lfs merge=lfs -text

aug_medium.pt

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

drowsiness_detection.py

@@ -0,0 +1,248 @@
+# PREP DEPENDENCIES
+from scipy.spatial import distance as dist
+from imutils import face_utils
+from threading import Thread
+import numpy as np
+import cv2 as cv
+import imutils
+import dlib
+import pygame  # Used for playing alarm sounds cross-platform
+import argparse
+import os
+
+# --- INITIALIZE MODELS AND CONSTANTS ---
+
+# Haar cascade classifier for face detection
+haar_cascade_face_detector = "haarcascade_frontalface_default.xml"
+face_detector = cv.CascadeClassifier(haar_cascade_face_detector)
+
+# Dlib facial landmark detector
+dlib_facial_landmark_predictor = "shape_predictor_68_face_landmarks.dat"
+landmark_predictor = dlib.shape_predictor(dlib_facial_landmark_predictor)
+
+# Important Variables
+font = cv.FONT_HERSHEY_SIMPLEX
+# --- INITIALIZE MODELS AND CONSTANTS ---
+# Eye Drowsiness Detection
+EYE_ASPECT_RATIO_THRESHOLD = 0.25
+EYE_CLOSED_THRESHOLD = 20
+EYE_THRESH_COUNTER = 0
+DROWSY_COUNTER = 0
+drowsy_alert = False
+
+# Mouth Yawn Detection
+MOUTH_ASPECT_RATIO_THRESHOLD = 0.5
+MOUTH_OPEN_THRESHOLD = 15
+YAWN_THRESH_COUNTER = 0
+YAWN_COUNTER = 0
+yawn_alert = False
+
+# NEW: Head Not Visible Detection
+FACE_LOST_THRESHOLD = 25  # Conseq. frames face must be lost to trigger alert
+FACE_LOST_COUNTER = 0
+HEAD_DOWN_COUNTER = 0 # Renaming for clarity
+head_down_alert = False
+
+# --- AUDIO SETUP (using Pygame) ---
+pygame.mixer.init()
+drowsiness_sound = pygame.mixer.Sound("drowsiness-detected.mp3")
+yawn_sound = pygame.mixer.Sound("yawning-detected.mp3")
+# head_down_sound = pygame.mixer.Sound("dependencies/audio/head-down-detected.mp3")
+
+# --- CORE FUNCTIONS ---
+def play_alarm(sound_to_play):
+    if not pygame.mixer.get_busy():
+        sound_to_play.play()
+
+def generate_alert(final_eye_ratio, final_mouth_ratio):
+    global EYE_THRESH_COUNTER, YAWN_THRESH_COUNTER
+    global drowsy_alert, yawn_alert
+    global DROWSY_COUNTER, YAWN_COUNTER
+
+    # Drowsiness check
+    if final_eye_ratio < EYE_ASPECT_RATIO_THRESHOLD:
+        EYE_THRESH_COUNTER += 1
+        if EYE_THRESH_COUNTER >= EYE_CLOSED_THRESHOLD:
+            if not drowsy_alert:
+                DROWSY_COUNTER += 1
+                drowsy_alert = True
+                Thread(target=play_alarm, args=(drowsiness_sound,)).start()
+    else:
+        EYE_THRESH_COUNTER = 0
+        drowsy_alert = False
+
+    # Yawn check
+    if final_mouth_ratio > MOUTH_ASPECT_RATIO_THRESHOLD:
+        YAWN_THRESH_COUNTER += 1
+        if YAWN_THRESH_COUNTER >= MOUTH_OPEN_THRESHOLD:
+            if not yawn_alert:
+                YAWN_COUNTER += 1
+                yawn_alert = True
+                Thread(target=play_alarm, args=(yawn_sound,)).start()
+    else:
+        YAWN_THRESH_COUNTER = 0
+        yawn_alert = False
+
+def detect_facial_landmarks(x, y, w, h, gray_frame):
+    face = dlib.rectangle(int(x), int(y), int(x + w), int(y + h))
+    face_landmarks = landmark_predictor(gray_frame, face)
+    face_landmarks = face_utils.shape_to_np(face_landmarks)
+    return face_landmarks
+
+def eye_aspect_ratio(eye):
+    A = dist.euclidean(eye[1], eye[5])
+    B = dist.euclidean(eye[2], eye[4])
+    C = dist.euclidean(eye[0], eye[3])
+    ear = (A + B) / (2.0 * C)
+    return ear
+
+def final_eye_aspect_ratio(shape):
+    (lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
+    (rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
+    left_eye = shape[lStart:lEnd]
+    right_eye = shape[rStart:rEnd]
+    left_ear = eye_aspect_ratio(left_eye)
+    right_ear = eye_aspect_ratio(right_eye)
+    final_ear = (left_ear + right_ear) / 2.0
+    return final_ear, left_eye, right_eye
+
+def mouth_aspect_ratio(mouth):
+    A = dist.euclidean(mouth[2], mouth[10])
+    B = dist.euclidean(mouth[4], mouth[8])
+    C = dist.euclidean(mouth[0], mouth[6])
+    mar = (A + B) / (2.0 * C)
+    return mar
+
+def final_mouth_aspect_ratio(shape):
+    (mStart, mEnd) = face_utils.FACIAL_LANDMARKS_IDXS["mouth"]
+    mouth = shape[mStart:mEnd]
+    return mouth_aspect_ratio(mouth), mouth
+
+def head_pose_ratio(shape):
+    nose_tip = shape[30]
+    chin_tip = shape[8]
+    left_face_corner = shape[0]
+    right_face_corner = shape[16]
+    nose_to_chin_dist = dist.euclidean(nose_tip, chin_tip)
+    face_width = dist.euclidean(left_face_corner, right_face_corner)
+    if face_width == 0:
+        return 0.0
+    hpr = nose_to_chin_dist / face_width
+    return hpr
+
+def reset_counters():
+    global EYE_THRESH_COUNTER, YAWN_THRESH_COUNTER, FACE_LOST_COUNTER
+    global DROWSY_COUNTER, YAWN_COUNTER, HEAD_DOWN_COUNTER
+    global drowsy_alert, yawn_alert, head_down_alert
+    EYE_THRESH_COUNTER, YAWN_THRESH_COUNTER, FACE_LOST_COUNTER = 0, 0, 0
+    DROWSY_COUNTER, YAWN_COUNTER, HEAD_DOWN_COUNTER = 0, 0, 0
+    drowsy_alert, yawn_alert, head_down_alert = False, False, False
+
+def process_frame(frame):
+    global FACE_LOST_COUNTER, head_down_alert, HEAD_DOWN_COUNTER
+    frame = imutils.resize(frame, width=640)
+    gray_frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+    faces = face_detector.detectMultiScale(gray_frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30), flags=cv.CASCADE_SCALE_IMAGE)
+    if len(faces) > 0:
+        FACE_LOST_COUNTER = 0
+        head_down_alert = False
+        (x, y, w, h) = faces[0]
+        face_landmarks = detect_facial_landmarks(x, y, w, h, gray_frame)
+        final_ear, left_eye, right_eye = final_eye_aspect_ratio(face_landmarks)
+        final_mar, mouth = final_mouth_aspect_ratio(face_landmarks)
+        # left_eye_hull, right_eye_hull, mouth_hull = cv.convexHull(left_eye), cv.convexHull(right_eye), cv.convexHull(mouth)
+        # cv.drawContours(frame, [left_eye_hull], -1, (0, 255, 0), 1)
+        # cv.drawContours(frame, [right_eye_hull], -1, (0, 255, 0), 1)
+        # cv.drawContours(frame, [mouth_hull], -1, (0, 255, 0), 1)
+        generate_alert(final_ear, final_mar)
+        cv.putText(frame, f"EAR: {final_ear:.2f}", (10, 30), font, 0.7, (0, 0, 255), 2)
+        cv.putText(frame, f"MAR: {final_mar:.2f}", (10, 60), font, 0.7, (0, 0, 255), 2)
+    else:
+        FACE_LOST_COUNTER += 1
+        if FACE_LOST_COUNTER >= FACE_LOST_THRESHOLD and not head_down_alert:
+            HEAD_DOWN_COUNTER += 1
+            head_down_alert = True
+    cv.putText(frame, f"Drowsy: {DROWSY_COUNTER}", (480, 30), font, 0.7, (255, 255, 0), 2)
+    cv.putText(frame, f"Yawn: {YAWN_COUNTER}", (480, 60), font, 0.7, (255, 255, 0), 2)
+    cv.putText(frame, f"Head Down: {HEAD_DOWN_COUNTER}", (480, 90), font, 0.7, (255, 255, 0), 2)
+    if drowsy_alert: cv.putText(frame, "DROWSINESS ALERT!", (150, 30), font, 0.9, (0, 0, 255), 2)
+    if yawn_alert: cv.putText(frame, "YAWN ALERT!", (200, 60), font, 0.9, (0, 0, 255), 2)
+    if head_down_alert: cv.putText(frame, "HEAD NOT VISIBLE!", (180, 90), font, 0.9, (0, 0, 255), 2)
+    return frame
+
+def process_video(input_path, output_path=None):
+    reset_counters()
+    video_stream = cv.VideoCapture(input_path)
+    if not video_stream.isOpened():
+        print(f"Error: Could not open video file {input_path}")
+        return False
+    
+    fps = int(video_stream.get(cv.CAP_PROP_FPS))
+    width = int(video_stream.get(cv.CAP_PROP_FRAME_WIDTH))
+    height = int(video_stream.get(cv.CAP_PROP_FRAME_HEIGHT))
+    
+    print(f"Processing video: {input_path}")
+    print(f"Original Res: {width}x{height}, FPS: {fps}")
+    
+    video_writer = None
+    if output_path:
+        fourcc = cv.VideoWriter_fourcc(*'mp4v')
+        # --- FIX: Calculate correct output dimensions to prevent corruption ---
+        # The process_frame function resizes frames to a fixed width of 640.
+        output_width = 640
+        # Maintain aspect ratio
+        output_height = int(height * (output_width / float(width)))
+        output_dims = (output_width, output_height)
+        video_writer = cv.VideoWriter(output_path, fourcc, fps, output_dims)
+        print(f"Outputting video with Res: {output_dims[0]}x{output_dims[1]}")
+
+    while True:
+        ret, frame = video_stream.read()
+        if not ret: break
+        
+        processed_frame = process_frame(frame)
+        if video_writer: video_writer.write(processed_frame)
+    
+    video_stream.release()
+    if video_writer: video_writer.release()
+    
+    print("Video processing complete!")
+    print(f"Final Stats - Drowsy: {DROWSY_COUNTER}, Yawn: {YAWN_COUNTER}, Head Down: {HEAD_DOWN_COUNTER}")
+    return True
+
+def run_webcam():
+    reset_counters()
+    video_stream = cv.VideoCapture(0)
+    if not video_stream.isOpened():
+        print("Error: Could not open webcam")
+        return False
+    while True:
+        ret, frame = video_stream.read()
+        if not ret:
+            print("Failed to grab frame")
+            break
+        processed_frame = process_frame(frame)
+        cv.imshow("Live Drowsiness and Yawn Detection", processed_frame)
+        if cv.waitKey(1) & 0xFF == ord('q'): break
+    video_stream.release()
+    cv.destroyAllWindows()
+    return True
+
+# --- MAIN EXECUTION LOOP ---
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Drowsiness Detection System')
+    parser.add_argument('--mode', choices=['webcam', 'video'], default='webcam', help='Mode of operation')
+    parser.add_argument('--input', type=str, help='Input video file path for video mode')
+    parser.add_argument('--output', type=str, help='Output video file path for video mode')
+    args = parser.parse_args()
+    
+    if args.mode == 'webcam':
+        print("Starting webcam detection...")
+        run_webcam()
+    elif args.mode == 'video':
+        if not args.input:
+            print("Error: --input argument is required for video mode.")
+        elif not os.path.exists(args.input):
+            print(f"Error: Input file not found at {args.input}")
+        else:
+            process_video(args.input, args.output)

shape_predictor_68_face_landmarks.dat

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

streamlit_app.py

@@ -0,0 +1,318 @@
+import asyncio
+import sys
+
+if sys.platform.startswith('linux') and sys.version_info >= (3, 8):
+    try:
+        asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+    except Exception:
+        pass
+import streamlit as st
+from PIL import Image
+import numpy as np
+import subprocess
+import time
+import tempfile
+import os
+from ultralytics import YOLO
+import cv2 as cv
+import pandas as pd
+
+model_path="best.pt"
+
+# --- Page Configuration ---
+st.set_page_config(
+    page_title="Driver Distraction System",
+    page_icon="🚗",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# --- Sidebar ---
+st.sidebar.title("🚗 Driver Distraction System")
+st.sidebar.write("Choose an option below:")
+
+# Sidebar navigation
+page = st.sidebar.radio("Select Feature", [
+    "Distraction System", 
+    "Real-time Drowsiness Detection",
+    "Video Drowsiness Detection"
+])
+
+# --- Class Labels (for YOLO model) ---
+class_names = ['drinking', 'hair and makeup', 'operating the radio', 'reaching behind',
+               'safe driving', 'talking on the phone', 'talking to passenger', 'texting']
+
+# Sidebar Class Name Display
+st.sidebar.subheader("Class Names")
+for idx, class_name in enumerate(class_names):
+    st.sidebar.write(f"{idx}: {class_name}")
+
+# --- Feature: YOLO Distraction Detection ---
+if page == "Distraction System":
+    st.title("Driver Distraction System")
+    st.write("Upload an image or video to detect distractions using YOLO model.")
+
+    # File type selection
+    file_type = st.radio("Select file type:", ["Image", "Video"])
+
+    if file_type == "Image":
+        uploaded_file = st.file_uploader("Upload Image", type=["jpg", "jpeg", "png"])
+        if uploaded_file is not None:
+            image = Image.open(uploaded_file).convert('RGB')
+            image_np = np.array(image)
+            col1, col2 = st.columns([1, 1])
+            with col1:
+                st.subheader("Uploaded Image")
+                st.image(image, caption="Original Image", use_container_width=True)
+            with col2:
+                st.subheader("Detection Results")
+                model = YOLO(model_path)
+                start_time = time.time()
+                results = model(image_np)
+                end_time = time.time()
+                prediction_time = end_time - start_time
+                result = results[0]
+                if len(result.boxes) > 0:
+                    boxes = result.boxes
+                    confidences = boxes.conf.cpu().numpy()
+                    classes = boxes.cls.cpu().numpy()
+                    class_names_dict = result.names
+                    max_conf_idx = confidences.argmax()
+                    predicted_class = class_names_dict[int(classes[max_conf_idx])]
+                    confidence_score = confidences[max_conf_idx]
+                    st.markdown(f"### Predicted Class: **{predicted_class}**")
+                    st.markdown(f"### Confidence Score: **{confidence_score:.4f}**  ({confidence_score*100:.1f}%)")
+                    st.markdown(f"Inference Time: {prediction_time:.2f} seconds")
+                else:
+                    st.warning("No distractions detected.")
+
+    else:  # Video processing
+        uploaded_video = st.file_uploader("Upload Video", type=["mp4", "avi", "mov", "mkv", "webm"])
+
+        if uploaded_video is not None:
+            tfile = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+            tfile.write(uploaded_video.read())
+            temp_input_path = tfile.name
+            temp_output_path = tempfile.mktemp(suffix="_distraction_detected.mp4")
+
+            st.subheader("Video Information")
+            cap = cv.VideoCapture(temp_input_path)
+            fps = cap.get(cv.CAP_PROP_FPS)
+            width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
+            total_frames = int(cap.get(cv.CAP_PROP_FRAME_COUNT))
+            duration = total_frames / fps if fps > 0 else 0
+            cap.release()
+
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Duration", f"{duration:.2f} seconds")
+                st.metric("Original FPS", f"{fps:.2f}")
+            with col2:
+                st.metric("Resolution", f"{width}x{height}")
+                st.metric("Total Frames", total_frames)
+
+            st.subheader("Original Video Preview")
+            st.video(uploaded_video)
+
+            if st.button("Process Video for Distraction Detection"):
+                TARGET_PROCESSING_FPS = 10
+                # --- NEW: Hyperparameter for the temporal smoothing logic ---
+                PERSISTENCE_CONFIDENCE_THRESHOLD = 0.40  # Stick with old class if found with >= 40% confidence
+
+                st.info(f"🚀 For faster results, video will be processed at ~{TARGET_PROCESSING_FPS} FPS.")
+                st.info(f"🧠 Applying temporal smoothing to reduce status flickering (Persistence Threshold: {PERSISTENCE_CONFIDENCE_THRESHOLD*100:.0f}%).")
+                
+                progress_bar = st.progress(0, text="Starting video processing...")
+                
+                with st.spinner(f"Processing video... This may take a while."):
+                    model = YOLO(model_path)
+                    cap = cv.VideoCapture(temp_input_path)
+                    
+                    fourcc = cv.VideoWriter_fourcc(*'mp4v')
+                    out = cv.VideoWriter(temp_output_path, fourcc, fps, (width, height))
+                    
+                    frame_skip_interval = max(1, round(fps / TARGET_PROCESSING_FPS))
+                    
+                    frame_count = 0
+                    last_best_box_coords = None
+                    last_best_box_label = ""
+                    last_status_text = "Status: Initializing..."
+                    last_status_color = (128, 128, 128)
+                    # --- NEW: State variable to store the last confirmed class ---
+                    last_confirmed_class_name = 'safe driving'
+
+                    while cap.isOpened():
+                        ret, frame = cap.read()
+                        if not ret:
+                            break
+                        
+                        frame_count += 1
+                        progress = int((frame_count / total_frames) * 100) if total_frames > 0 else 0
+                        progress_bar.progress(progress, text=f"Analyzing frame {frame_count}/{total_frames}")
+                        
+                        annotated_frame = frame.copy()
+
+                        if frame_count % frame_skip_interval == 0:
+                            results = model(annotated_frame)
+                            result = results[0]
+                            
+                            last_best_box_coords = None # Reset box for this processing cycle
+
+                            if len(result.boxes) > 0:
+                                boxes = result.boxes
+                                class_names_dict = result.names
+                                confidences = boxes.conf.cpu().numpy()
+                                classes = boxes.cls.cpu().numpy()
+
+                                # --- NEW STABILITY LOGIC ---
+                                final_box_to_use = None
+                                
+                                # 1. Check if the last known class exists with reasonable confidence
+                                for i in range(len(boxes)):
+                                    current_class_name = class_names_dict[int(classes[i])]
+                                    if current_class_name == last_confirmed_class_name and confidences[i] >= PERSISTENCE_CONFIDENCE_THRESHOLD:
+                                        final_box_to_use = boxes[i]
+                                        break
+                                
+                                # 2. If not, fall back to the highest confidence detection in the current frame
+                                if final_box_to_use is None:
+                                    max_conf_idx = confidences.argmax()
+                                    final_box_to_use = boxes[max_conf_idx]
+                                # --- END OF NEW LOGIC ---
+
+                                # Now, process the determined "final_box_to_use"
+                                x1, y1, x2, y2 = final_box_to_use.xyxy[0].cpu().numpy()
+                                confidence = final_box_to_use.conf[0].cpu().numpy()
+                                class_id = int(final_box_to_use.cls[0].cpu().numpy())
+                                class_name = class_names_dict[class_id]
+
+                                # Update the state for the next frames
+                                last_confirmed_class_name = class_name 
+                                last_best_box_coords = (int(x1), int(y1), int(x2), int(y2))
+                                last_best_box_label = f"{class_name}: {confidence:.2f}"
+                                
+                                if class_name != 'safe driving':
+                                    last_status_text = f"Status: {class_name.replace('_', ' ').title()}"
+                                    last_status_color = (0, 0, 255)
+                                else:
+                                    last_status_text = "Status: Safe Driving"
+                                    last_status_color = (0, 128, 0)
+                            else:
+                                # No detections, reset to safe driving
+                                last_confirmed_class_name = 'safe driving'
+                                last_status_text = "Status: Safe Driving"
+                                last_status_color = (0, 128, 0)
+                        
+                        # Draw annotations on EVERY frame using the last known data
+                        if last_best_box_coords:
+                            cv.rectangle(annotated_frame, (last_best_box_coords[0], last_best_box_coords[1]), 
+                                         (last_best_box_coords[2], last_best_box_coords[3]), (0, 255, 0), 2)
+                            cv.putText(annotated_frame, last_best_box_label, 
+                                       (last_best_box_coords[0], last_best_box_coords[1] - 10), 
+                                       cv.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+
+                        # Draw status text
+                        font_scale, font_thickness = 1.0, 2
+                        (text_w, text_h), _ = cv.getTextSize(last_status_text, cv.FONT_HERSHEY_SIMPLEX, font_scale, font_thickness)
+                        padding = 10
+                        rect_start = (padding, padding)
+                        rect_end = (padding + text_w + padding, padding + text_h + padding)
+                        cv.rectangle(annotated_frame, rect_start, rect_end, last_status_color, -1)
+                        text_pos = (padding + 5, padding + text_h + 5)
+                        cv.putText(annotated_frame, last_status_text, text_pos, cv.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255), font_thickness)
+                        
+                        out.write(annotated_frame)
+                    
+                    cap.release()
+                    out.release()
+                    progress_bar.progress(100, text="Video processing completed!")
+                    
+                    st.success("Video processed successfully!")
+                    
+                    if os.path.exists(temp_output_path):
+                        with open(temp_output_path, "rb") as file:
+                            video_bytes = file.read()
+                        
+                        st.download_button(
+                            label="📥 Download Processed Video",
+                            data=video_bytes,
+                            file_name=f"distraction_detected_{uploaded_video.name}",
+                            mime="video/mp4",
+                            key="download_distraction_video"
+                        )
+                        
+                        st.subheader("Sample Frame from Processed Video")
+                        cap_out = cv.VideoCapture(temp_output_path)
+                        ret, frame = cap_out.read()
+                        if ret:
+                            frame_rgb = cv.cvtColor(frame, cv.COLOR_BGR2RGB)
+                            st.image(frame_rgb, caption="Sample frame with distraction detection", use_container_width=True)
+                        cap_out.release()
+                
+                try:
+                    os.unlink(temp_input_path)
+                    if os.path.exists(temp_output_path): os.unlink(temp_output_path)
+                except Exception as e:
+                    st.warning(f"Failed to clean up temporary files: {e}")
+
+# --- Feature: Real-time Drowsiness Detection ---
+elif page == "Real-time Drowsiness Detection":
+    st.title("🧠 Real-time Drowsiness Detection")
+    st.write("This will open your webcam and run the detection script.")
+    if st.button("Start Drowsiness Detection"):
+        with st.spinner("Launching webcam..."):
+            subprocess.Popen(["python3", "drowsiness_detection.py", "--mode", "webcam"])
+        st.success("Drowsiness detection started in a separate window. Press 'q' in that window to quit.")
+
+# --- Feature: Video Drowsiness Detection ---
+elif page == "Video Drowsiness Detection":
+    st.title("📹 Video Drowsiness Detection")
+    st.write("Upload a video file to detect drowsiness and download the processed video.")
+    uploaded_video = st.file_uploader("Upload Video", type=["mp4", "avi", "mov", "mkv", "webm"])
+    if uploaded_video is not None:
+        tfile = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+        tfile.write(uploaded_video.read())
+        temp_input_path = tfile.name
+        temp_output_path = tempfile.mktemp(suffix="_processed.mp4")
+        st.subheader("Original Video Preview")
+        st.video(uploaded_video)
+        if st.button("Process Video for Drowsiness Detection"):
+            progress_bar = st.progress(0, text="Preparing to process video...")
+            with st.spinner("Processing video... This may take a while."):
+                process = subprocess.Popen([
+                    "python3", "drowsiness_detection.py", 
+                    "--mode", "video",
+                    "--input", temp_input_path,
+                    "--output", temp_output_path
+                ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                stdout, stderr = process.communicate()
+                if process.returncode == 0:
+                    progress_bar.progress(100, text="Video processing completed!")
+                    if os.path.exists(temp_output_path):
+                        st.success("Video processed successfully!")
+                        if stdout: st.code(stdout)
+                        with open(temp_output_path, "rb") as file: video_bytes = file.read()
+                        st.download_button(
+                            label="📥 Download Processed Video",
+                            data=video_bytes,
+                            file_name=f"drowsiness_detected_{uploaded_video.name}",
+                            mime="video/mp4",
+                            key="download_processed_video"
+                        )
+                        st.subheader("Sample Frame from Processed Video")
+                        cap = cv.VideoCapture(temp_output_path)
+                        ret, frame = cap.read()
+                        if ret: st.image(cv.cvtColor(frame, cv.COLOR_BGR2RGB), caption="Sample frame with drowsiness detection", use_container_width=True)
+                        cap.release()
+                    else:
+                        st.error("Error: Processed video file not found.")
+                        if stderr: st.code(stderr)
+                else:
+                    st.error("An error occurred during video processing.")
+                    if stderr: st.code(stderr)
+            try:
+                if os.path.exists(temp_input_path): os.unlink(temp_input_path)
+                if os.path.exists(temp_output_path): os.unlink(temp_output_path)
+            except Exception as e:
+                st.warning(f"Failed to clean up temporary files: {e}")

video_processor.py

@@ -0,0 +1,142 @@
+"""
+Video Processing Utility for Drowsiness Detection
+This script provides a more robust video processing interface
+"""
+
+import cv2 as cv
+import os
+import json
+from datetime import datetime
+import argparse
+
+def get_video_info(video_path):
+    """Get detailed video information"""
+    cap = cv.VideoCapture(video_path)
+    
+    if not cap.isOpened():
+        return None
+    
+    info = {
+        'fps': cap.get(cv.CAP_PROP_FPS),
+        'width': int(cap.get(cv.CAP_PROP_FRAME_WIDTH)),
+        'height': int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)),
+        'total_frames': int(cap.get(cv.CAP_PROP_FRAME_COUNT)),
+        'duration': cap.get(cv.CAP_PROP_FRAME_COUNT) / cap.get(cv.CAP_PROP_FPS) if cap.get(cv.CAP_PROP_FPS) > 0 else 0,
+        'codec': int(cap.get(cv.CAP_PROP_FOURCC)),
+        'file_size': os.path.getsize(video_path)
+    }
+    
+    cap.release()
+    return info
+
+def create_processing_report(input_path, output_path, stats):
+    """Create a JSON report of the processing results"""
+    report = {
+        'timestamp': datetime.now().isoformat(),
+        'input_file': input_path,
+        'output_file': output_path,
+        'video_info': get_video_info(input_path),
+        'detection_stats': stats,
+        'processing_info': {
+            'software': 'Drowsiness Detection System',
+            'version': '1.0'
+        }
+    }
+    
+    report_path = output_path.replace('.mp4', '_report.json')
+    with open(report_path, 'w') as f:
+        json.dump(report, f, indent=2)
+    
+    return report_path
+
+def process_video_with_progress(input_path, output_path, progress_callback=None):
+    """
+    Process video with progress callback
+    progress_callback: function that takes (current_frame, total_frames)
+    """
+    # Import the drowsiness detection functions
+    from drowsiness_detection import process_frame, reset_counters
+    from drowsiness_detection import DROWSY_COUNTER, YAWN_COUNTER, HEAD_DOWN_COUNTER
+    
+    reset_counters()
+    
+    # Open video file
+    video_stream = cv.VideoCapture(input_path)
+    
+    if not video_stream.isOpened():
+        raise ValueError(f"Could not open video file {input_path}")
+    
+    # Get video properties
+    fps = int(video_stream.get(cv.CAP_PROP_FPS))
+    width = int(video_stream.get(cv.CAP_PROP_FRAME_WIDTH))
+    height = int(video_stream.get(cv.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(video_stream.get(cv.CAP_PROP_FRAME_COUNT))
+    
+    # Setup video writer
+    fourcc = cv.VideoWriter_fourcc(*'mp4v')
+    video_writer = cv.VideoWriter(output_path, fourcc, fps, (640, 480))
+    
+    frame_count = 0
+    
+    try:
+        while True:
+            ret, frame = video_stream.read()
+            if not ret:
+                break
+            
+            frame_count += 1
+            
+            # Process frame
+            processed_frame = process_frame(frame)
+            
+            # Write frame to output video
+            video_writer.write(processed_frame)
+            
+            # Call progress callback if provided
+            if progress_callback:
+                progress_callback(frame_count, total_frames)
+        
+        # Get final stats
+        stats = {
+            'total_frames': frame_count,
+            'drowsy_events': DROWSY_COUNTER,
+            'yawn_events': YAWN_COUNTER,
+            'head_down_events': HEAD_DOWN_COUNTER
+        }
+        
+        return stats
+        
+    finally:
+        video_stream.release()
+        video_writer.release()
+
+def main():
+    parser = argparse.ArgumentParser(description='Video Processing Utility for Drowsiness Detection')
+    parser.add_argument('--input', '-i', required=True, help='Input video file path')
+    parser.add_argument('--output', '-o', help='Output video file path (optional)')
+    parser.add_argument('--report', '-r', action='store_true', help='Generate processing report')
+    parser.add_argument('--info', action='store_true', help='Show video information only')
+    
+    args = parser.parse_args()
+    
+    if not os.path.exists(args.input):
+        print(f"Error: Input file {args.input} does not exist")
+        return
+    
+    # Show video info
+    if args.info:
+        info = get_video_info(args.input)
+        if info:
+            print(f"Video Information for: {args.input}")
+            print(f"Resolution: {info['width']}x{info['height']}")
+            print(f"FPS: {info['fps']:.2f}")
+            print(f"Duration: {info['duration']:.2f} seconds")
+            print(f"Total Frames: {info['total_frames']}")
+            print(f"File Size: {info['file_size'] / (1024*1024):.2f} MB")
+        else:
+            print("Error: Could not read video file")
+        return
+    
+    # Generate output path if not provided
+    if not args.output:
+        base_name