Update app.py

app.py

@@ -2,59 +2,56 @@ import gradio as gr
 from PIL import Image
 import numpy as np
 
-def brightness_to_opacity_overlay(foreground_img, background_img, invert_opacity=False):
-    if foreground_img is None or background_img is None:
+def brightness_to_opacity_overlay(fg_img, bg_img, invert_opacity=False):
+    if fg_img is None or bg_img is None:
         return None
 
-    # Ensure images are RGBA and same size
-    bg = background_img.convert("RGBA")
-    fg = foreground_img.convert("RGB").resize(bg.size)
+    # Convert images
+    fg = fg_img.convert("RGB")
+    bg = bg_img.convert("RGBA")
 
-    # Convert to luminance (brightness)
-    fg_np = np.array(fg)
-    brightness = np.dot(fg_np[..., :3], [0.299, 0.587, 0.114]).astype(np.uint8)
+    # Resize fg to match bg
+    fg = fg.resize(bg.size)
 
-    # Optionally invert
-    alpha = 255 - brightness if invert_opacity else brightness
+    # Convert to brightness
+    fg_np = np.array(fg).astype(np.float32)
+    luminance = np.dot(fg_np[..., :3], [0.299, 0.587, 0.114])
+    if invert_opacity:
+        luminance = 255 - luminance
+    alpha = (luminance / 255.0).clip(0, 1)
 
-    # Create white RGBA with computed alpha
-    white_rgb = np.full_like(fg_np, 255)
-    overlay_rgba = np.dstack((white_rgb, alpha)).astype(np.uint8)
-    overlay = Image.fromarray(overlay_rgba, mode="RGBA")
+    # Make white RGB with computed alpha
+    overlay_rgb = np.ones_like(fg_np) * 255
+    overlay_rgba = np.dstack((overlay_rgb, alpha * 255)).astype(np.uint8)
 
-    # Use the alpha from overlay as a mask on the background
-    bg_np = np.array(bg).astype(np.float32)
-    ov_np = np.array(overlay).astype(np.float32)
+    # Convert both to float for blending
+    overlay = overlay_rgba.astype(np.float32) / 255.0
+    bg_np = np.array(bg).astype(np.float32) / 255.0
 
-    alpha_fg = ov_np[..., 3:4] / 255.0
-    alpha_bg = bg_np[..., 3:4] / 255.0
+    # Premultiplied alpha blend
+    fg_a = overlay[..., 3:4]
+    bg_a = bg_np[..., 3:4]
+    out_a = fg_a + bg_a * (1 - fg_a)
+    out_rgb = (overlay[..., :3] * fg_a + bg_np[..., :3] * bg_a * (1 - fg_a)) / np.maximum(out_a, 1e-6)
 
-    # Blend RGB
-    out_rgb = (ov_np[..., :3] * alpha_fg + bg_np[..., :3] * alpha_bg * (1 - alpha_fg))
-    out_alpha = alpha_fg + alpha_bg * (1 - alpha_fg)
-
-    # Avoid divide-by-zero
-    out_rgb = np.divide(out_rgb, out_alpha, where=(out_alpha != 0))
-
-    # Combine back to RGBA
-    out_rgba = np.dstack((out_rgb, out_alpha)) * 255
-    result = Image.fromarray(out_rgba.astype(np.uint8), mode="RGBA")
-
-    return result
+    # Final image
+    result_np = np.dstack((out_rgb, out_a)).clip(0, 1) * 255
+    result_img = Image.fromarray(result_np.astype(np.uint8), mode="RGBA")
+    return result_img
 
 # Gradio UI
 iface = gr.Interface(
     fn=brightness_to_opacity_overlay,
     inputs=[
-        gr.Image(type="pil", label="Mask Source (Brightness to Alpha)"),
-        gr.Image(type="pil", label="Background Image (with transparency OK)"),
-        gr.Checkbox(label="Invert Opacity", value=False)
+        gr.Image(type="pil", label="Alpha From Brightness (Foreground)"),
+        gr.Image(type="pil", label="Background Image (May Have Transparency)"),
+        gr.Checkbox(label="Invert Brightness", value=False)
     ],
-    outputs=gr.Image(type="pil", label="Composite Result"),
-    title="Brightness-to-Alpha Overlay (Transparent-Safe)",
+    outputs=gr.Image(type="pil", label="Composite Output"),
+    title="⚡ Accurate Brightness-to-Alpha Overlay",
     description=(
-        "Uses the brightness of one image as an alpha mask and overlays it "
-        "on a background image — works properly even when background has transparency."
+        "This tool uses brightness as alpha, resizes to match background, "
+        "and blends correctly — even with transparent backgrounds."
     )
 )