Update app.py

app.py

@@ -1,53 +1,36 @@
-"""
-Hugging Face App: Face Detection in Video
------------------------------------------
-Uploads a video → detects faces → returns processed video.
-"""
+# app.py — face detection in video using MediaPipe-Face-Detection model
 
-import gradio as gr
 import cv2
 import torch
-import numpy as np
+import gradio as gr
 import tempfile
+import numpy as np
 from transformers import AutoProcessor, AutoModelForObjectDetection
 
+MODEL_ID = "qualcomm/MediaPipe-Face-Detection"
 
-MODEL_ID = "avaabedi/deepface-detector"
-
-# Load model + processor (only once)
 processor = AutoProcessor.from_pretrained(MODEL_ID)
 model = AutoModelForObjectDetection.from_pretrained(MODEL_ID)
 model.eval()
 
-
-def detect_faces_in_frame(frame):
-    """Detect faces in a single frame using HF model."""
-    inputs = processor(images=frame, return_tensors="pt")
+def detect_faces_in_frame(frame_rgb: np.ndarray, threshold: float = 0.5):
+    inputs = processor(images=frame_rgb, return_tensors="pt")
     with torch.no_grad():
         outputs = model(**inputs)
+    processed = processor.post_process_object_detection(outputs, threshold=threshold)[0]
+    return processed["boxes"], processed["scores"], processed["labels"]
 
-    results = processor.post_process_object_detection(
-        outputs,
-        threshold=0.5
-    )[0]
-
-    return results["boxes"], results["scores"], results["labels"]
-
-
-def process_video(video_path):
-    """Reads video, detects faces frame-by-frame, draws boxes, writes output video."""
+def process_video(video_path: str, threshold: float = 0.5):
     cap = cv2.VideoCapture(video_path)
     if not cap.isOpened():
-        return "Error: cannot read video."
+        return None
 
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    w  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    h  = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap.get(cv2.CAP_PROP_FPS) or 24.0
+    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
-    # Output video file
     temp_out = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
     out_path = temp_out.name
-
     fourcc = cv2.VideoWriter_fourcc(*"mp4v")
     writer = cv2.VideoWriter(out_path, fourcc, fps, (w, h))
 
@@ -56,37 +39,30 @@ def process_video(video_path):
         if not ret:
             break
 
-        # Detect faces
-        boxes, scores, labels = detect_faces_in_frame(frame)
+        # convert BGR → RGB for model
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+        boxes, scores, labels = detect_faces_in_frame(frame_rgb, threshold)
 
-        # Draw detections
         for box, score in zip(boxes, scores):
             x1, y1, x2, y2 = map(int, box.tolist())
             cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
             cv2.putText(frame, f"{score:.2f}", (x1, y1 - 5),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)
 
         writer.write(frame)
 
     cap.release()
     writer.release()
-
     return out_path
 
-
-# ------------------------------------------------
-#               GRADIO UI
-# ------------------------------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎥 Face Detection in Video (Hugging Face)")
-
-    video_input = gr.Video(label="Upload a video")  # no type=
-    process_btn = gr.Button("Detect Faces")
-
-    video_output = gr.Video(label="Output Video")
+    gr.Markdown("# Video Face Detection")
+    video_in = gr.Video(label="Upload video")
+    process_button = gr.Button("Detect Faces")
+    video_out = gr.Video(label="Processed Video")
 
-    process_btn.click(fn=process_video,
-                      inputs=video_input,
-                      outputs=video_output)
+    process_button.click(fn=process_video, inputs=video_in, outputs=video_out)
 
-demo.launch(server_name="0.0.0.0", share=True)
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", share=True)