Create app.py

app.py

@@ -0,0 +1,157 @@
+import gradio as gr
+from PIL import Image, ImageOps
+import numpy as np
+
+# --- Filter Functions ---
+# Each function takes a PIL Image and returns a processed PIL Image.
+
+def apply_grayscale(image):
+    """Converts the image to grayscale."""
+    if image is None:
+        return None
+    return ImageOps.grayscale(image.convert("RGB"))
+
+def apply_sepia(image):
+    """Applies a sepia tone filter to the image."""
+    if image 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"))
+
+def apply_posterize(image):
+    """Reduces the number of bits for each color channel."""
+    if image is None:
+        return None
+    # Posterize to 4 bits per channel
+    return ImageOps.posterize(image.convert("RGB"), 4)
+
+def apply_solarize(image):
+    """Inverts pixel values above a threshold."""
+    if image is None:
+        return None
+    return ImageOps.solarize(image.convert("RGB"), threshold=128)
+
+# --- Main Processing Function ---
+def apply_filter(image, filter_name):
+    """
+    Dispatcher function that calls the appropriate filter
+    based on the user's selection.
+    """
+    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
+
+    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
+    }
+    
+    # Get the function from the map and apply it
+    filter_function = filter_map.get(filter_name, lambda img: img)
+    return filter_function(pil_image)
+
+# --- 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;
+}
+"""
+
+with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Old School Image Filters", elem_id="title")
+    gr.Markdown("Apply classic filters to your images or live webcam feed. All processing is done on the server's CPU.", elem_id="subtitle")
+
+    filter_choices = ["None", "Grayscale", "Sepia", "Invert", "Posterize", "Solarize"]
+
+    with gr.Tabs():
+        with gr.TabItem("Live Webcam"):
+            with gr.Row(equal_height=True):
+                with gr.Column():
+                    webcam_input = gr.Image(sources=["webcam"], streaming=True, label="Webcam Input")
+                with gr.Column():
+                    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)
+
+        with gr.TabItem("Image File"):
+            with gr.Row(equal_height=True):
+                with gr.Column():
+                    upload_input = gr.Image(type="pil", label="Upload an Image")
+                with gr.Column():
+                    upload_output = gr.Image(label="Filtered Output")
+            upload_filter = gr.Radio(filter_choices, value="None", label="Select Filter")
+            
+            gr.Examples(
+                examples=[
+                    ["./examples/cat.jpg", "Sepia"],
+                    ["./examples/cheetah.jpg", "Posterize"],
+                    ["./examples/lion.jpg", "Grayscale"],
+                ],
+                inputs=[upload_input, upload_filter],
+                outputs=upload_output,
+                fn=apply_filter,
+                cache_examples=True
+            )
+
+            # 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)
+
+# Create a dummy examples directory for local testing
+if not demo.examples:
+    import os
+    os.makedirs("examples", exist_ok=True)
+    try:
+        # Create a simple placeholder image
+        Image.new('RGB', (200, 200), color = 'red').save('examples/cat.jpg')
+        Image.new('RGB', (200, 200), color = 'green').save('examples/cheetah.jpg')
+        Image.new('RGB', (200, 200), color = 'blue').save('examples/lion.jpg')
+    except Exception as e:
+        print(f"Could not create example images: {e}")
+
+
+if __name__ == "__main__":
+    demo.launch(debug=True)