Added updated files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.idea/

app.py

@@ -1,7 +1,255 @@
 import gradio as gr
+import cv2
+import numpy as np
+from ultralytics import YOLO
+import threading
+import time
 
-def greet(name):
-    return "Hello " + name + "!!"
+# Load YOLO model
+model = YOLO("best.pt")
+CLASS_NAMES = ["hard hat", "mask"]
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# Global variables for camera streaming
+camera_active = False
+current_frame = None
+frame_lock = threading.Lock()
+
+# -------------------
+# Video File Processing
+# -------------------
+def predict_video(input_file, selected_classes):
+    if input_file is None:
+        return None, "No file uploaded"
+
+    cap = cv2.VideoCapture(input_file)
+    if not cap.isOpened():
+        return None, "Could not read input file"
+
+    # Video writer setup
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    out_path = "output.mp4"
+    out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
+
+    tally_counts = {cls: 0 for cls in selected_classes}
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        results = model.predict(frame, conf=0.25, verbose=False)
+        frame_out = frame.copy()
+
+        for r in results:
+            for box in r.boxes:
+                cls_id = int(box.cls[0])
+                conf = float(box.conf[0])
+                label = CLASS_NAMES[cls_id] if cls_id < len(CLASS_NAMES) else f"cls{cls_id}"
+
+                if label in selected_classes:
+                    x1, y1, x2, y2 = map(int, box.xyxy[0])
+                    cv2.rectangle(frame_out, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                    cv2.putText(frame_out, f"{label} {conf:.2f}",
+                                (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
+                                (0, 255, 0), 2)
+                    tally_counts[label] += 1
+
+        out.write(frame_out)
+
+    cap.release()
+    out.release()
+
+    tally_text = "\n".join([f"{cls}: {count} detections" for cls, count in tally_counts.items()])
+    return out_path, tally_text
+
+# -------------------
+# Live Camera Functions
+# -------------------
+def camera_thread():
+    """Background thread to capture camera frames"""
+    global camera_active, current_frame
+
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        print("Error: Could not open camera")
+        return
+
+    # Set camera properties for better performance
+    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
+    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+    cap.set(cv2.CAP_PROP_FPS, 30)
+
+    while camera_active:
+        ret, frame = cap.read()
+        if ret:
+            with frame_lock:
+                current_frame = frame.copy()
+        time.sleep(0.033)  # ~30 FPS
+
+    cap.release()
+
+def start_camera():
+    """Start the camera streaming"""
+    global camera_active
+    camera_active = True
+    camera_thread_obj = threading.Thread(target=camera_thread, daemon=True)
+    camera_thread_obj.start()
+    return "Camera started"
+
+def stop_camera():
+    """Stop the camera streaming"""
+    global camera_active
+    camera_active = False
+    return "Camera stopped"
+
+def get_camera_frame(selected_classes):
+    """Get current camera frame with detections"""
+    global current_frame
+
+    if not camera_active or current_frame is None:
+        return None
+
+    with frame_lock:
+        frame = current_frame.copy()
+
+    # Run YOLO detection
+    results = model.predict(frame, conf=0.25, verbose=False)
+    frame_out = frame.copy()
+
+    detection_count = {cls: 0 for cls in selected_classes}
+
+    for r in results:
+        for box in r.boxes:
+            cls_id = int(box.cls[0])
+            conf = float(box.conf[0])
+            label = CLASS_NAMES[cls_id] if cls_id < len(CLASS_NAMES) else f"cls{cls_id}"
+
+            if label in selected_classes:
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+                cv2.rectangle(frame_out, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                cv2.putText(frame_out, f"{label} {conf:.2f}",
+                            (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
+                            (0, 255, 0), 2)
+                detection_count[label] += 1
+
+    # Convert BGR to RGB for Gradio
+    frame_rgb = cv2.cvtColor(frame_out, cv2.COLOR_BGR2RGB)
+
+    # Create tally text
+    tally_text = "\n".join([f"{cls}: {count} detections" for cls, count in detection_count.items()])
+
+    return frame_rgb, tally_text
+
+# -------------------
+# Dynamic UI Update
+# -------------------
+def update_ui(mode):
+    if mode == "Upload Video":
+        return (
+            gr.update(visible=True),   # input_file
+            gr.update(visible=True),   # output_video
+            gr.update(visible=False),  # output_img
+            gr.update(visible=True),   # run_btn
+            gr.update(visible=False),  # start_btn
+            gr.update(visible=False),  # stop_btn
+            gr.update(visible=False)   # live_display
+        )
+    else:  # Live Camera
+        return (
+            gr.update(visible=False),  # input_file
+            gr.update(visible=False),  # output_video
+            gr.update(visible=True),   # output_img
+            gr.update(visible=False),  # run_btn
+            gr.update(visible=True),   # start_btn
+            gr.update(visible=True),   # stop_btn
+            gr.update(visible=True)    # live_display
+        )
+
+# -------------------
+# Gradio Interface
+# -------------------
+with gr.Blocks() as demo:
+    gr.Markdown("## 🦺 YOLOv11 Hard Hat & Mask Detector")
+
+    with gr.Row():
+        with gr.Column():
+            mode = gr.Radio(["Upload Video", "Live Camera"], value="Upload Video", label="Mode")
+            input_file = gr.File(label="Upload Video", type="filepath", visible=True)
+            class_toggle = gr.CheckboxGroup(CLASS_NAMES, value=["hard hat", "mask"], label="Select classes")
+
+            # Buttons
+            run_btn = gr.Button("Run Detection", visible=True)
+            start_btn = gr.Button("Start Camera", visible=False)
+            stop_btn = gr.Button("Stop Camera", visible=False)
+
+        with gr.Column():
+            output_video = gr.Video(label="Detection Output", visible=True)
+            output_img = gr.Image(type="numpy", label="Live Detection", visible=False)
+            tally_box = gr.Textbox(label="Detection Count", interactive=False)
+
+            # Live display component (hidden initially)
+            live_display = gr.HTML(visible=False)
+
+    # Dynamically show/hide components based on mode
+    mode.change(
+        update_ui,
+        inputs=mode,
+        outputs=[input_file, output_video, output_img, run_btn, start_btn, stop_btn, live_display]
+    )
+
+    # Video processing
+    def run_detection(input_file, selected_classes):
+        return predict_video(input_file, selected_classes)
+
+    run_btn.click(
+        run_detection,
+        inputs=[input_file, class_toggle],
+        outputs=[output_video, tally_box]
+    )
+
+    # Camera controls
+    start_btn.click(start_camera, outputs=tally_box)
+    stop_btn.click(stop_camera, outputs=tally_box)
+
+    # Live camera feed update
+    def update_live_feed(selected_classes):
+        if camera_active:
+            return get_camera_frame(selected_classes)
+        return None, ""
+
+    # Manual refresh button for live feed
+    with gr.Row():
+        refresh_btn = gr.Button("Refresh Live Feed", visible=False)
+
+    # Update refresh button visibility based on mode
+    def update_refresh_visibility(mode):
+        return gr.update(visible=(mode == "Live Camera"))
+
+    mode.change(update_refresh_visibility, inputs=mode, outputs=refresh_btn)
+
+    # Add refresh functionality
+    refresh_btn.click(
+        update_live_feed,
+        inputs=[class_toggle],
+        outputs=[output_img, tally_box]
+    )
+
+    # Timer-based update for live camera (runs every 500ms when in live mode)
+    def timer_update(selected_classes, mode):
+        if mode == "Live Camera" and camera_active:
+            return update_live_feed(selected_classes)
+        return gr.update(), ""
+
+    # Create a timer that updates the live feed
+    timer = gr.Timer(value=0.5)  # 500ms intervals
+    timer.tick(
+        fn=timer_update,
+        inputs=[class_toggle, mode],
+        outputs=[output_img, tally_box]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

best.pt

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

output.mp4

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