Update app.py

app.py

@@ -2,53 +2,59 @@ import gradio as gr
 from PIL import Image
 import numpy as np
 
-def white_from_brightness_overlay(fg_img, bg_img, invert_opacity=False):
-    if fg_img is None or bg_img is None:
+def brightness_to_white_alpha(img, bg=None, invert_opacity=False):
+    if img is None:
         return None
 
-    # Resize fg to match bg
-    bg = bg_img.convert("RGBA")
-    fg = fg_img.convert("RGB").resize(bg.size)
+    # Convert image to RGB and get brightness
+    img = img.convert("RGB")
+    img_np = np.array(img).astype(np.float32)
+    brightness = np.dot(img_np[..., :3], [0.299, 0.587, 0.114])  # shape: (H, W)
 
-    # Convert to NumPy arrays
-    fg_np = np.array(fg).astype(np.float32)
-    bg_np = np.array(bg).astype(np.float32) / 255.0
-
-    # Calculate brightness
-    brightness = np.dot(fg_np[..., :3], [0.299, 0.587, 0.114])  # shape (H, W)
     if invert_opacity:
         brightness = 255 - brightness
-    alpha = (brightness / 255.0).clip(0, 1)  # shape (H, W)
 
-    # Create solid white with alpha from brightness
-    white = np.ones_like(fg_np)  # 255,255,255
-    white_alpha = np.dstack((white, alpha * 255)).astype(np.uint8)  # shape (H, W, 4)
+    # Normalize brightness to alpha (0.0–1.0), then scale back to 0–255
+    alpha = (brightness / 255.0).clip(0, 1)
+    alpha = (alpha * 255).astype(np.uint8)
+
+    # Create pure white RGB
+    white = np.ones_like(img_np, dtype=np.uint8) * 255  # shape: (H, W, 3)
+
+    # Combine white RGB and computed alpha
+    white_alpha = np.dstack((white, alpha)).astype(np.uint8)  # shape: (H, W, 4)
+
     white_img = Image.fromarray(white_alpha, mode="RGBA")
-    white_np = np.array(white_img).astype(np.float32) / 255.0
 
-    # Blend white image over background using premultiplied alpha
-    fg_a = white_np[..., 3:4]
-    bg_a = bg_np[..., 3:4]
-    out_a = fg_a + bg_a * (1 - fg_a)
-    out_rgb = (white_np[..., :3] * fg_a + bg_np[..., :3] * bg_a * (1 - fg_a)) / np.maximum(out_a, 1e-6)
+    # If background is provided, overlay white on top
+    if bg:
+        bg = bg.convert("RGBA").resize(white_img.size)
+        white_np = np.array(white_img).astype(np.float32) / 255.0
+        bg_np = np.array(bg).astype(np.float32) / 255.0
+
+        fg_a = white_np[..., 3:4]
+        bg_a = bg_np[..., 3:4]
+        out_a = fg_a + bg_a * (1 - fg_a)
+        out_rgb = (white_np[..., :3] * fg_a + bg_np[..., :3] * bg_a * (1 - fg_a)) / np.maximum(out_a, 1e-6)
+
+        result = np.dstack((out_rgb, out_a)).clip(0, 1) * 255
+        return Image.fromarray(result.astype(np.uint8), mode="RGBA")
 
-    # Final output
-    result = np.dstack((out_rgb, out_a)).clip(0, 1) * 255
-    return Image.fromarray(result.astype(np.uint8), mode="RGBA")
+    return white_img
 
 # Gradio UI
 iface = gr.Interface(
-    fn=white_from_brightness_overlay,
+    fn=brightness_to_white_alpha,
     inputs=[
-        gr.Image(type="pil", label="Input Image (Used for Brightness Only)"),
-        gr.Image(type="pil", label="Background Image (Can Have Transparency)"),
-        gr.Checkbox(label="Invert Brightness", value=False)
+        gr.Image(type="pil", label="Input Image"),
+        gr.Image(type="pil", label="Optional Background Image"),
+        gr.Checkbox(label="Invert Brightness → Alpha", value=False)
     ],
-    outputs=gr.Image(type="pil", label="Final Output"),
-    title="✨ White Brightness-to-Alpha Overlay",
+    outputs=gr.Image(type="pil", label="White with Alpha"),
+    title="🎛️ Brightness to White Alpha Image",
     description=(
-        "Uses the brightness of the input image to generate alpha. RGB is replaced with white. "
-        "Result is a smooth glowing white shape over your background, respecting transparency."
+        "Generates a pure white image where opacity = brightness of input. "
+        "Darker = more transparent, lighter = more opaque. Optional overlay on background."
     )
 )