Update app.py

app.py

@@ -1,46 +1,48 @@
 import gradio as gr
-from PIL import Image, ImageFilter
+from PIL import Image
 
-def enhance_pixel_art(img, downscale_factor, num_colors, blur_radius):
+def pixel_block_downsample(img, block_size):
     """
-    Enhances pixel art by:
-    1. Blurring the image slightly to remove high-frequency artifacts.
-    2. Downsampling the image using a high-quality filter.
-    3. Upscaling back using nearest-neighbor interpolation to preserve blocky pixels.
-    4. Quantizing the image to reduce the number of colors.
+    Downsample the image by shrinking it and then re-upscaling
+    with nearest neighbor to create large, chunky 'pixel blocks'.
     """
-    # Ensure image is in RGB mode
+    # Ensure the image is in RGB
     if img.mode != "RGB":
         img = img.convert("RGB")
     
-    # Apply a slight Gaussian blur to smooth out artifacts
-    im_blur = img.filter(ImageFilter.GaussianBlur(radius=blur_radius))
+    w, h = img.size
     
-    # Downscale using a high-quality resampling filter (Lanczos)
-    new_size = (max(1, im_blur.width // downscale_factor),
-                max(1, im_blur.height // downscale_factor))
-    im_down = im_blur.resize(new_size, Image.LANCZOS)
+    # Avoid zero or negative
+    if block_size < 1:
+        block_size = 1
     
-    # Upscale back using nearest-neighbor to maintain a pixelated look
-    im_up = im_down.resize(img.size, Image.NEAREST)
+    # Compute the size to downscale to
+    new_w = max(1, w // block_size)
+    new_h = max(1, h // block_size)
     
-    # Quantize to reduce the number of colors (using median cut)
-    im_quant = im_up.quantize(colors=num_colors, method=Image.MEDIANCUT, dither=Image.NONE)
-    return im_quant
+    # Downscale using a high-quality filter (e.g. BICUBIC or LANCZOS)
+    img_small = img.resize((new_w, new_h), resample=Image.BICUBIC)
+    
+    # Upscale back using nearest-neighbor for the chunky pixel look
+    img_blocky = img_small.resize((w, h), resample=Image.NEAREST)
+    return img_blocky
 
-# Create a Gradio interface with image input, sliders for parameters, and image output.
-iface = gr.Interface(
-    fn=enhance_pixel_art,
-    inputs=[
-        gr.Image(type="pil", label="Input Image"),
-        gr.Slider(2, 8, value=4, step=1, label="Downscale Factor"),
-        gr.Slider(2, 32, value=16, step=1, label="Number of Colors"),
-        gr.Slider(0.0, 5.0, value=0.5, step=0.1, label="Blur Radius")
-    ],
-    outputs=gr.Image(type="pil", label="Enhanced Pixel Art"),
-    title="Pixel Art Enhancer"
-)
+def gradio_app():
+    # Gradio interface with a slider for the "Pixel Block Size"
+    iface = gr.Interface(
+        fn=pixel_block_downsample,
+        inputs=[
+            gr.Image(type="pil", label="Upload Image"),
+            gr.Slider(
+                minimum=1, maximum=64, step=1, value=8,
+                label="Choose Pixel Block Size"
+            )
+        ],
+        outputs=gr.Image(type="pil", label="Downsampled Output"),
+        title="Pixel Block Downsampler"
+    )
+    return iface
 
-# Launch the demo. (In a Hugging Face Space, this script will be run automatically.)
 if __name__ == "__main__":
-    iface.launch()
+    # For local testing; on Hugging Face Spaces, this script is run automatically.
+    gradio_app().launch()