Update app.py

app.py

@@ -1,82 +1,101 @@
 import gradio as gr
 from PIL import Image, ImageOps
 import numpy as np
+import cv2 # Using OpenCV for fast resizing
 
-# --- Filter Functions ---
-# Each function takes a PIL Image and returns a processed PIL Image.
+# --- Optimized Filter Functions ---
+# Each function now takes a NumPy array and returns a processed NumPy array for speed.
 
-def apply_grayscale(image):
-    """Converts the image to grayscale."""
-    if image is None:
+def apply_grayscale(img_np):
+    """Converts the image to grayscale using the luminosity method."""
+    if img_np is None:
         return None
-    return ImageOps.grayscale(image.convert("RGB"))
+    # Using dot product for weighted sum is very fast
+    return np.dot(img_np[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
 
-def apply_sepia(image):
-    """Applies a sepia tone filter to the image."""
-    if image is None:
+def apply_sepia(img_np):
+    """Applies a sepia tone filter using a fast NumPy matrix operation."""
+    if img_np is None:
         return None
-    img = image.convert("RGB")
-    width, height = img.size
-    pixels = img.load()
-
-    for py in range(height):
-        for px in range(width):
-            r, g, b = img.getpixel((px, py))
-            tr = int(0.393 * r + 0.769 * g + 0.189 * b)
-            tg = int(0.349 * r + 0.686 * g + 0.168 * b)
-            tb = int(0.272 * r + 0.534 * g + 0.131 * b)
-            if tr > 255: tr = 255
-            if tg > 255: tg = 255
-            if tb > 255: tb = 255
-            pixels[px, py] = (tr, tg, tb)
-    return img
-
-def apply_invert(image):
-    """Inverts the colors of the image."""
-    if image is None:
-        return None
-    return ImageOps.invert(image.convert("RGB"))
+    
+    # Sepia transformation matrix
+    sepia_matrix = np.array([
+        [0.393, 0.769, 0.189],
+        [0.349, 0.686, 0.168],
+        [0.272, 0.534, 0.131]
+    ]).T # Transpose for correct dot product with RGB vectors
+    
+    # Apply the matrix transformation and clip to valid 0-255 range
+    sepia_img = img_np.dot(sepia_matrix)
+    return np.clip(sepia_img, 0, 255).astype(np.uint8)
 
-def apply_posterize(image):
-    """Reduces the number of bits for each color channel."""
-    if image is None:
+def apply_invert(img_np):
+    """Inverts the colors of the image using NumPy."""
+    if img_np is None:
         return None
-    # Posterize to 4 bits per channel
-    return ImageOps.posterize(image.convert("RGB"), 4)
+    return 255 - img_np
 
-def apply_solarize(image):
-    """Inverts pixel values above a threshold."""
-    if image is None:
+def apply_posterize(img_np):
+    """Reduces the number of bits for each color channel using NumPy."""
+    if img_np is None:
         return None
-    return ImageOps.solarize(image.convert("RGB"), threshold=128)
+    # This is a fast way to posterize using bitwise operations
+    bits = 4
+    shift = 8 - bits
+    return ((img_np >> shift) << shift).astype(np.uint8)
+
+def apply_solarize(img_np):
+    """Inverts pixel values above a threshold using NumPy."""
+    if img_np is None:
+        return None
+    threshold = 128
+    # Create a boolean mask for pixels above the threshold
+    hot_pixels = img_np > threshold
+    # Invert only those pixels
+    img_np[hot_pixels] = 255 - img_np[hot_pixels]
+    return img_np
+
+# --- Main Processing Functions ---
 
-# --- Main Processing Function ---
-def apply_filter(image, filter_name):
+def process_static_image(image, filter_name):
     """
-    Dispatcher function that calls the appropriate filter
-    based on the user's selection.
+    Processes an uploaded PIL image. No resizing is done.
     """
     if image is None:
         return None
     
-    # Convert Gradio's numpy array to a PIL Image if necessary
-    if isinstance(image, np.ndarray):
-        pil_image = Image.fromarray(image)
-    else:
-        pil_image = image
-
+    # Convert PIL Image to NumPy array for processing
+    img_np = np.array(image)
+    
     filter_map = {
         "Grayscale": apply_grayscale,
         "Sepia": apply_sepia,
         "Invert": apply_invert,
         "Posterize": apply_posterize,
         "Solarize": apply_solarize,
-        "None": lambda img: img # Return original if no filter
+        "None": lambda img: img
     }
     
-    # Get the function from the map and apply it
     filter_function = filter_map.get(filter_name, lambda img: img)
-    return filter_function(pil_image)
+    processed_np = filter_function(img_np)
+    
+    # Return NumPy array, Gradio will handle conversion to displayable image
+    return processed_np
+
+def process_live_frame(frame, filter_name):
+    """
+    Processes a live webcam frame. Includes a resizing step for performance.
+    """
+    if frame is None:
+        return None
+
+    # --- OPTIMIZATION: Reduce resolution of the live feed ---
+    # Resize the frame to 640x480 for faster processing
+    resized_frame = cv2.resize(frame, (640, 480), interpolation=cv2.INTER_AREA)
+    
+    # The rest of the logic is the same as the static image processing
+    return process_static_image(Image.fromarray(resized_frame), filter_name)
+
 
 # --- Gradio UI ---
 css = """
@@ -112,9 +131,9 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
                     webcam_output = gr.Image(label="Filtered Output")
             webcam_filter = gr.Radio(filter_choices, value="None", label="Select Filter")
             
-            # When the webcam input or filter changes, apply the filter
-            webcam_input.stream(apply_filter, [webcam_input, webcam_filter], webcam_output)
-            webcam_filter.change(apply_filter, [webcam_input, webcam_filter], webcam_output)
+            # Use the optimized function for live frames
+            webcam_input.stream(process_live_frame, [webcam_input, webcam_filter], webcam_output)
+            webcam_filter.change(process_live_frame, [webcam_input, webcam_filter], webcam_output)
 
         with gr.TabItem("Image File"):
             with gr.Row(equal_height=True):
@@ -124,9 +143,9 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
                     upload_output = gr.Image(label="Filtered Output")
             upload_filter = gr.Radio(filter_choices, value="None", label="Select Filter")
             
-            # When the uploaded image or filter changes, apply the filter
-            upload_input.change(apply_filter, [upload_input, upload_filter], upload_output)
-            upload_filter.change(apply_filter, [upload_input, upload_filter], upload_output)
+            # Use the standard function for static images
+            upload_input.change(process_static_image, [upload_input, upload_filter], upload_output)
+            upload_filter.change(process_static_image, [upload_input, upload_filter], upload_output)
 
 
 if __name__ == "__main__":