Update app.py

app.py

@@ -5,38 +5,36 @@ import cv2 # Using OpenCV for fast resizing and filtering
 import requests
 import os
 
-# --- Face Detection Setup ---
-# Download the Haar Cascade model for face detection if it doesn't exist
+# --- Asset Setup ---
+# Function to download a file from a URL
+def download_file(url, filename):
+    if not os.path.exists(filename):
+        print(f"Downloading {filename}...")
+        try:
+            r = requests.get(url, timeout=10)
+            r.raise_for_status()
+            with open(filename, 'wb') as f:
+                f.write(r.content)
+            print("Download complete.")
+            return True
+        except requests.exceptions.RequestException as e:
+            print(f"Error downloading {filename}: {e}")
+            return False
+    return True
+
+# Download Haar Cascade for face detection
 haar_cascade_url = "https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_default.xml"
 haar_cascade_filename = "haarcascade_frontalface_default.xml"
-if not os.path.exists(haar_cascade_filename):
-    print(f"Downloading {haar_cascade_filename}...")
-    try:
-        r = requests.get(haar_cascade_url, timeout=10)
-        r.raise_for_status()  # Raise an exception for bad status codes
-        with open(haar_cascade_filename, 'wb') as f:
-            f.write(r.content)
-        print("Download complete.")
-        face_cascade = cv2.CascadeClassifier(haar_cascade_filename)
-    except requests.exceptions.RequestException as e:
-        print(f"Error downloading Haar Cascade model: {e}")
-        face_cascade = None
-else:
+face_cascade = None
+if download_file(haar_cascade_url, haar_cascade_filename):
     face_cascade = cv2.CascadeClassifier(haar_cascade_filename)
 
-
-# Create a sunglasses image with transparency programmatically
-def create_sunglasses_mask():
-    sunglasses = Image.new('RGBA', (300, 100), (0, 0, 0, 0))
-    draw = ImageDraw.Draw(sunglasses)
-    # Lenses
-    draw.ellipse((20, 20, 130, 80), fill='black')
-    draw.ellipse((170, 20, 280, 80), fill='black')
-    # Bridge
-    draw.line((130, 50, 170, 50), fill='black', width=10)
-    return sunglasses
-
-sunglasses_img = create_sunglasses_mask()
+# Download Metamask logo for face effect
+metamask_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/36/MetaMask_Fox.svg/1024px-MetaMask_Fox.svg.png"
+metamask_filename = "metamask_logo.png"
+metamask_img = None
+if download_file(metamask_url, metamask_filename):
+    metamask_img = Image.open(metamask_filename).convert("RGBA")
 
 
 # --- Optimized Filter Functions ---
@@ -91,13 +89,11 @@ def apply_sharpen(img_np):
     return cv2.filter2D(img_np, -1, kernel)
 
 def apply_sunglasses(img_np):
-    """Detects faces and overlays sunglasses."""
     if img_np is None or face_cascade is None: return img_np
-    
+    sunglasses_img = create_sunglasses_mask()
     pil_image = Image.fromarray(img_np)
     gray = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-
     for (x, y, w, h) in faces:
         sunglasses_width = int(w * 0.9)
         sunglasses_height = int(sunglasses_width * sunglasses_img.height / sunglasses_img.width)
@@ -105,73 +101,115 @@ def apply_sunglasses(img_np):
         pos_y = y + int(h * 0.2)
         resized_sunglasses = sunglasses_img.resize((sunglasses_width, sunglasses_height))
         pil_image.paste(resized_sunglasses, (pos_x, pos_y), resized_sunglasses)
-        
     return np.array(pil_image)
 
+def apply_metamask_head(img_np):
+    """Detects faces and overlays a Metamask logo."""
+    if img_np is None or face_cascade is None or metamask_img is None: return img_np
+    pil_image = Image.fromarray(img_np)
+    gray = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+    for (x, y, w, h) in faces:
+        # Make the logo slightly larger than the face and position it
+        logo_width = int(w * 1.4)
+        logo_height = int(logo_width * metamask_img.height / metamask_img.width)
+        pos_x = x - int((logo_width - w) / 2)
+        pos_y = y - int(logo_height * 0.2) # Position it slightly higher
+        resized_logo = metamask_img.resize((logo_width, logo_height))
+        pil_image.paste(resized_logo, (pos_x, pos_y), resized_logo)
+    return np.array(pil_image)
+
+# Helper for sunglasses
+def create_sunglasses_mask():
+    sunglasses = Image.new('RGBA', (300, 100), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(sunglasses)
+    draw.ellipse((20, 20, 130, 80), fill='black')
+    draw.ellipse((170, 20, 280, 80), fill='black')
+    draw.line((130, 50, 170, 50), fill='black', width=10)
+    return sunglasses
 
 # --- Main Processing Functions ---
-def process_static_image(image, filter_name):
+def process_image(image, filter_name):
     if image is None: return None
-    img_np = np.array(image.convert("RGB"))
     
+    # Convert PIL Image to NumPy array for processing
+    if isinstance(image, Image.Image):
+        img_np = np.array(image.convert("RGB"))
+    else: # It's already a numpy array from the webcam
+        img_np = image
+
     filter_map = {
         "Grayscale": apply_grayscale, "Sepia": apply_sepia, "Invert": apply_invert,
         "Posterize": apply_posterize, "Solarize": apply_solarize, "Vignette": apply_vignette,
         "Contour": apply_contour, "Sharpen": apply_sharpen, "Sunglasses": apply_sunglasses,
-        "None": lambda img: img
+        "Metamask Head": apply_metamask_head, "None": lambda img: img
     }
     
     filter_function = filter_map.get(filter_name, lambda img: img)
-    processed_np = filter_function(img_np)
-    return processed_np
+    return filter_function(img_np)
 
 def process_live_frame(frame, filter_name):
     if frame is None: return None
     resized_frame = cv2.resize(frame, (640, 480), interpolation=cv2.INTER_AREA)
-    return process_static_image(Image.fromarray(resized_frame), filter_name)
-
+    return process_image(resized_frame, filter_name)
 
 # --- Gradio UI ---
 css = """
 #title { text-align: center; color: #1d1e22; font-size: 2.8em; font-weight: 700; }
 #subtitle { text-align: center; color: #57606a; font-size: 1.2em; }
-.gradio-container { max-width: 980px !important; margin: auto !important; }
+.gradio-container { max-width: 1080px !important; margin: auto !important; }
 """
 
 with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
     gr.Markdown("# Image Filters: Old, New & Face Effects", elem_id="title")
     gr.Markdown("Apply classic and modern filters to your images or live webcam feed.", elem_id="subtitle")
 
-    filter_choices = [
-        "None", 
-        "--- Old School ---", "Grayscale", "Sepia", "Invert", "Posterize", "Solarize",
-        "--- New School ---", "Vignette", "Contour", "Sharpen",
-        "--- Face Effects ---", "Sunglasses"
-    ]
-
     with gr.Tabs():
         with gr.TabItem("Live Webcam"):
             with gr.Row(equal_height=True):
-                with gr.Column():
+                with gr.Column(scale=2):
                     webcam_input = gr.Image(sources=["webcam"], streaming=True, label="Webcam Input")
-                with gr.Column():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Filter Controls")
+                    with gr.Accordion("Old School", open=True):
+                        webcam_radio_old = gr.Radio(["None", "Grayscale", "Sepia", "Invert", "Posterize", "Solarize"], label="Filter", value="None")
+                    with gr.Accordion("New School", open=True):
+                        webcam_radio_new = gr.Radio(["None", "Vignette", "Contour", "Sharpen"], label="Filter", value="None")
+                    with gr.Accordion("Face Effects", open=True):
+                        webcam_radio_face = gr.Radio(["None", "Sunglasses", "Metamask Head"], label="Filter", value="None")
+                with gr.Column(scale=2):
                     webcam_output = gr.Image(label="Filtered Output")
-            webcam_filter = gr.Radio(filter_choices, value="None", label="Select Filter")
             
-            webcam_input.stream(process_live_frame, [webcam_input, webcam_filter], webcam_output)
-            webcam_filter.change(process_live_frame, [webcam_input, webcam_filter], webcam_output)
+            # Link radio buttons to the stream
+            webcam_radio_old.change(process_live_frame, [webcam_input, webcam_radio_old], webcam_output).then(lambda: "None", None, webcam_radio_new).then(lambda: "None", None, webcam_radio_face)
+            webcam_radio_new.change(process_live_frame, [webcam_input, webcam_radio_new], webcam_output).then(lambda: "None", None, webcam_radio_old).then(lambda: "None", None, webcam_radio_face)
+            webcam_radio_face.change(process_live_frame, [webcam_input, webcam_radio_face], webcam_output).then(lambda: "None", None, webcam_radio_old).then(lambda: "None", None, webcam_radio_new)
+            webcam_input.stream(lambda img, r1, r2, r3: process_live_frame(img, next(f for f in (r1,r2,r3) if f != "None")), [webcam_input, webcam_radio_old, webcam_radio_new, webcam_radio_face], webcam_output)
 
         with gr.TabItem("Image File"):
             with gr.Row(equal_height=True):
-                with gr.Column():
+                with gr.Column(scale=2):
                     upload_input = gr.Image(type="pil", sources=["upload"], label="Upload an Image")
-                with gr.Column():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Filter Controls")
+                    with gr.Accordion("Old School", open=True):
+                        upload_radio_old = gr.Radio(["None", "Grayscale", "Sepia", "Invert", "Posterize", "Solarize"], label="Filter", value="None")
+                    with gr.Accordion("New School", open=True):
+                        upload_radio_new = gr.Radio(["None", "Vignette", "Contour", "Sharpen"], label="Filter", value="None")
+                    with gr.Accordion("Face Effects", open=True):
+                        upload_radio_face = gr.Radio(["None", "Sunglasses", "Metamask Head"], label="Filter", value="None")
+                with gr.Column(scale=2):
                     upload_output = gr.Image(label="Filtered Output")
-            upload_filter = gr.Radio(filter_choices, value="None", label="Select Filter")
-            
-            upload_input.change(process_static_image, [upload_input, upload_filter], upload_output)
-            upload_filter.change(process_static_image, [upload_input, upload_filter], upload_output)
 
+            # Link radio buttons to the static image processor
+            def upload_filter_change(img, r1, r2, r3):
+                active_filter = next((f for f in (r1, r2, r3) if f != "None"), "None")
+                return process_image(img, active_filter)
+
+            upload_radio_old.change(upload_filter_change, [upload_input, upload_radio_old, upload_radio_new, upload_radio_face], upload_output).then(lambda: "None", None, upload_radio_new).then(lambda: "None", None, upload_radio_face)
+            upload_radio_new.change(upload_filter_change, [upload_input, upload_radio_old, upload_radio_new, upload_radio_face], upload_output).then(lambda: "None", None, upload_radio_old).then(lambda: "None", None, upload_radio_face)
+            upload_radio_face.change(upload_filter_change, [upload_input, upload_radio_old, upload_radio_new, upload_radio_face], upload_output).then(lambda: "None", None, upload_radio_old).then(lambda: "None", None, upload_radio_new)
+            upload_input.change(upload_filter_change, [upload_input, upload_radio_old, upload_radio_new, upload_radio_face], upload_output)
 
 if __name__ == "__main__":
     demo.launch(debug=True)