Update app.py

app.py

@@ -6,56 +6,55 @@ def brightness_to_opacity_overlay(foreground_img, background_img, invert_opacity
     if foreground_img is None or background_img is None:
         return None
 
-    # Resize foreground to match background
+    # Ensure images are RGBA and same size
     bg = background_img.convert("RGBA")
     fg = foreground_img.convert("RGB").resize(bg.size)
 
-    # Convert to luminance (grayscale)
-    fg_array = np.array(fg)
-    luminance = np.dot(fg_array[...,:3], [0.299, 0.587, 0.114]).astype(np.uint8)
+    # Convert to luminance (brightness)
+    fg_np = np.array(fg)
+    brightness = np.dot(fg_np[..., :3], [0.299, 0.587, 0.114]).astype(np.uint8)
 
-    # Invert if requested
-    alpha = 255 - luminance if invert_opacity else luminance
+    # Optionally invert
+    alpha = 255 - brightness if invert_opacity else brightness
 
-    # Create white RGBA image with computed alpha
-    white_rgb = np.ones_like(fg_array) * 255
-    rgba_array = np.dstack((white_rgb, alpha)).astype(np.uint8)
-    overlay = Image.fromarray(rgba_array, mode="RGBA")
+    # 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")
 
-    # Manual alpha blending
-    bg_arr = np.array(bg).astype(np.float32) / 255.0
-    ov_arr = np.array(overlay).astype(np.float32) / 255.0
+    # 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)
 
-    # Extract alpha channels
-    alpha_bg = bg_arr[..., 3:4]
-    alpha_ov = ov_arr[..., 3:4]
+    alpha_fg = ov_np[..., 3:4] / 255.0
+    alpha_bg = bg_np[..., 3:4] / 255.0
 
-    # Composite alpha and color
-    out_alpha = alpha_ov + alpha_bg * (1 - alpha_ov)
-    out_rgb = (
-        ov_arr[..., :3] * alpha_ov +
-        bg_arr[..., :3] * alpha_bg * (1 - alpha_ov)
-    ) / np.clip(out_alpha, 1e-6, 1)
+    # 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)
 
-    # Combine and convert to final image
-    out_image = np.dstack((out_rgb, out_alpha)).clip(0, 1) * 255
-    out_image = Image.fromarray(out_image.astype(np.uint8), mode="RGBA")
+    # Avoid divide-by-zero
+    out_rgb = np.divide(out_rgb, out_alpha, where=(out_alpha != 0))
 
-    return out_image
+    # 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
 
 # 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 or without transparency)"),
+        gr.Image(type="pil", label="Background Image (with transparency OK)"),
         gr.Checkbox(label="Invert Opacity", value=False)
     ],
-    outputs=gr.Image(type="pil", label="Final Composite"),
-    title="Brightness-to-Alpha Overlay Tool (with Transparency Fix)",
+    outputs=gr.Image(type="pil", label="Composite Result"),
+    title="Brightness-to-Alpha Overlay (Transparent-Safe)",
     description=(
-        "Uses the brightness of the first image as alpha, resizes to match the second image, "
-        "and overlays correctly even when the background has transparency."
+        "Uses the brightness of one image as an alpha mask and overlays it "
+        "on a background image — works properly even when background has transparency."
     )
 )