webcam - video, not a snapshot

app.py

@@ -2,41 +2,76 @@ import gradio as gr
 import cv2
 import numpy as np
 
+# Load the face detection model (using OpenCV's built-in classifier)
+# This is a fast, reliable model that works well for real-time applications.
 face_cascade = cv2.CascadeClassifier(
     cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
 )
 
-def mask_image(image):
-    """Apply mask to a single image (not streaming)"""
-    if image is None:
+def apply_zorro_mask(frame: np.ndarray) -> np.ndarray:
+    """
+    This function is called for every frame from your webcam.
+    It detects faces and draws a Zorro mask on them.
+    """
+    if frame is None:
         return None
 
-    # Convert to BGR for OpenCV
-    frame = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    # The frame from Gradio is in RGB, but OpenCV uses BGR.
+    # Convert to BGR for processing, then back to RGB for display.
+    frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
 
-    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+    # Convert the frame to grayscale, which is required for the face detector
+    gray = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2GRAY)
 
+    # Detect faces in the image
+    # The parameters (scaleFactor, minNeighbors) can be tuned for better performance
+    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(60, 60))
+
+    # Loop over all detected faces and draw the mask
     for (x, y, w, h) in faces:
-        # Zorro mask
-        cv2.rectangle(frame, (x, y + int(h*0.35)),
-                     (x + w, y + int(h*0.65)), (0, 0, 0), -1)
-        # Eye holes
-        cv2.circle(frame, (x + int(w*0.35), y + int(h*0.5)),
-                  int(w*0.1), (255, 255, 255), -1)
-        cv2.circle(frame, (x + int(w*0.65), y + int(h*0.5)),
-                  int(w*0.1), (255, 255, 255), -1)
-
-    return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-
-# Simple interface - user clicks "Capture" then "Submit"
-demo = gr.Interface(
-    fn=mask_image,
-    inputs=gr.Image(sources=["webcam"], type="numpy"),
-    outputs=gr.Image(),
-    title="Zorro Mask",
-    description="1. Allow camera access\n2. Click 'Capture'\n3. Click 'Submit'\n4. See the mask!",
-    examples=None
-)
+        # --- Draw the black Zorro mask (a rectangle over the eyes) ---
+        mask_height = int(h * 0.4)  # Make the mask cover the upper part of the face
+        mask_y = y + int(h * 0.2)   # Position it a bit below the top of the face
+        cv2.rectangle(frame_bgr, (x, mask_y), (x + w, mask_y + mask_height), (0, 0, 0), -1) # -1 fills the rectangle
+
+        # --- Create eye holes (two white circles) ---
+        eye_y = mask_y + int(mask_height * 0.5)
+        eye_radius = int(w * 0.1)
+        # Left eye hole
+        cv2.circle(frame_bgr, (x + int(w * 0.35), eye_y), eye_radius, (255, 255, 255), -1)
+        # Right eye hole
+        cv2.circle(frame_bgr, (x + int(w * 0.65), eye_y), eye_radius, (255, 255, 255), -1)
+
+        # --- Optional: Draw a stylish "Z" mark on the mask ---
+        cv2.putText(frame_bgr, "Z", (x + w - 30, y + h - 20),
+                    cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 255), 3)
+
+    # Convert the frame back to RGB for Gradio to display
+    frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+    return frame_rgb
+
+# --- Build the Gradio Interface ---
+# The 'Blocks' API gives us more control than the simple 'Interface' API.
+with gr.Blocks(title="Real-Time Zorro Mask Sandbox") as demo:
+    gr.Markdown("# 🎭 Real-Time Zorro Mask Sandbox")
+    gr.Markdown("Allow webcam access. The mask will be applied to your face in real-time!")
+
+    with gr.Row():
+        # Input: The live webcam stream. 'streaming=True' is crucial.
+        input_webcam = gr.Image(sources=["webcam"], streaming=True, label="Your Webcam Feed")
+        # Output: Where the processed video stream will be shown.
+        output_video = gr.Image(label="Live Zorro Mask Output")
+
+    # This is the magic line that creates the real-time loop.
+    # It calls 'apply_zorro_mask' for every new frame from 'input_webcam'
+    # and sends the result to 'output_video'.
+    input_webcam.stream(
+        fn=apply_zorro_mask,
+        inputs=input_webcam,
+        outputs=output_video,
+        time_limit=10,      # Optional: Stops the stream after 10 seconds if no new frames
+        stream_every=0.05   # Optional: Controls the delay between frames (in seconds). Lower is faster.
+    )
 
+# Launch the app
 demo.launch()