Create app.py

app.py

@@ -0,0 +1,244 @@
+import gradio as gr
+from PIL import Image
+import numpy as np
+
+def create_empty_image():
+    """
+    Create an empty transparent image (512x512, RGBA mode).
+    :return: Empty PIL.Image object.
+    """
+    return Image.new("RGBA", (512, 512), (0, 0, 0, 0))
+
+def overlay_images(images, alphas, positions):
+    """
+    Overlay multiple semi-transparent layers and control their positions.
+    :param images: List of uploaded images (PIL.Image objects).
+    :param alphas: List of transparency values for each layer (floats between 0 and 1).
+    :param positions: List of positions for each layer, format: [(x1, y1), (x2, y2), ...].
+    :return: Overlayed image with transparent background, overlayed image with black background, and list of individual layer images.
+    """
+    if not images:
+        return None, None, []
+
+    # Create a transparent canvas (1024x1024)
+    transparent_canvas = Image.new("RGBA", (1024, 1024), (0, 0, 0, 0))
+    # Create a black canvas (1024x1024)
+    black_canvas = Image.new("RGBA", (1024, 1024), (0, 0, 0, 255))
+    layer_images = []  # Store individual layer images
+
+    # Overlay each layer
+    for i, img in enumerate(images):
+        # Ensure the image is a PIL.Image object
+        if not isinstance(img, Image.Image):
+            img = create_empty_image()
+        # Resize the layer to 512x512
+        layer = img.convert("RGBA").resize((512, 512))
+        # Set transparency
+        layer = Image.fromarray(
+            (np.array(layer) * np.array([1, 1, 1, alphas[i]])).astype(np.uint8)
+        )
+        # Get layer position
+        x, y = positions[i]
+        # Expand from bottom-left to top-right
+        x_offset = x  # X coordinate starts from 0 and expands to the right
+        y_offset = 1024 - y - layer.height  # Y coordinate starts from the bottom and expands upward
+        # Paste the layer onto the transparent canvas
+        transparent_canvas.paste(layer, (x_offset, y_offset), layer)
+        # Paste the layer onto the black canvas
+        black_canvas.paste(layer, (x_offset, y_offset), layer)
+
+        # Generate individual layer image
+        layer_canvas = Image.new("RGBA", (1024, 1024), (0, 0, 0, 0))
+        layer_canvas.paste(layer, (x_offset, y_offset), layer)
+        layer_images.append(layer_canvas)
+
+    # If there are fewer than 4 layers, fill with empty images
+    while len(layer_images) < 4:
+        layer_images.append(create_empty_image())
+
+    return transparent_canvas, black_canvas, layer_images
+
+def crop_image(image, crop_x_min, crop_x_max, crop_y_min, crop_y_max):
+    """
+    Crop an image.
+    :param image: Input image (PIL.Image object).
+    :param crop_x_min: X-axis crop start point.
+    :param crop_x_max: X-axis crop end point.
+    :param crop_y_min: Y-axis crop start point.
+    :param crop_y_max: Y-axis crop end point.
+    :return: Cropped image (PIL.Image object).
+    """
+    if image is None:
+        return None
+    # Ensure the crop range is within the image dimensions
+    x_min = max(0, min(crop_x_min, image.width))
+    x_max = max(0, min(crop_x_max, image.width))
+    y_min = max(0, min(crop_y_min, image.height))
+    y_max = max(0, min(crop_y_max, image.height))
+    # Crop the image
+    return image.crop((x_min, y_min, x_max, y_max))
+
+def update_output(image1, image2, image3, image4, alpha1, alpha2, alpha3, alpha4, x1, y1, x2, y2, x3, y3, x4, y4, crop_x_min, crop_x_max, crop_y_min, crop_y_max):
+    """
+    Update the output images.
+    :param image1, image2, image3, image4: Uploaded images.
+    :param alpha1, alpha2, alpha3, alpha4: Transparency values for each layer.
+    :param x1, y1, x2, y2, x3, y3, x4, y4: Positions for each layer.
+    :param crop_x_min: X-axis crop start point.
+    :param crop_x_max: X-axis crop end point.
+    :param crop_y_min: Y-axis crop start point.
+    :param crop_y_max: Y-axis crop end point.
+    :return: Cropped transparent background image, black background image, and individual layer images.
+    """
+    # Print logs to check the type and content of each input
+    print("image1:", type(image1), image1)
+    print("image2:", type(image2), image2)
+    print("image3:", type(image3), image3)
+    print("image4:", type(image4), image4)
+    print("alpha1:", type(alpha1), alpha1)
+    print("alpha2:", type(alpha2), alpha2)
+    print("alpha3:", type(alpha3), alpha3)
+    print("alpha4:", type(alpha4), alpha4)
+    print("x1:", type(x1), x1)
+    print("y1:", type(y1), y1)
+    print("x2:", type(x2), x2)
+    print("y2:", type(y2), y2)
+    print("x3:", type(x3), x3)
+    print("y3:", type(y3), y3)
+    print("x4:", type(x4), x4)
+    print("y4:", type(y4), y4)
+    print("crop_x_min:", type(crop_x_min), crop_x_min)
+    print("crop_x_max:", type(crop_x_max), crop_x_max)
+    print("crop_y_min:", type(crop_y_min), crop_y_min)
+    print("crop_y_max:", type(crop_y_max), crop_y_max)
+
+    # If an image is None, use an empty image
+    images = [
+        image1 if image1 is not None else create_empty_image(),
+        image2 if image2 is not None else create_empty_image(),
+        image3 if image3 is not None else create_empty_image(),
+        image4 if image4 is not None else create_empty_image()
+    ]
+    alphas = [alpha1, alpha2, alpha3, alpha4]  # Transparency list
+    positions = [(x1, y1), (x2, y2), (x3, y3), (x4, y4)]  # Position list
+
+    # Call the overlay function
+    transparent_image, black_image, layer_images = overlay_images(images, alphas, positions)
+
+    # Crop the output images
+    transparent_image = crop_image(transparent_image, crop_x_min, crop_x_max, crop_y_min, crop_y_max)
+    black_image = crop_image(black_image, crop_x_min, crop_x_max, crop_y_min, crop_y_max)
+    layer_images = [crop_image(img, crop_x_min, crop_x_max, crop_y_min, crop_y_max) for img in layer_images]
+
+    # Return 6 values (cropped transparent background image + black background image + 4 individual layer images)
+    return [transparent_image, black_image] + layer_images
+
+# Example data
+example_images = [
+    Image.open("furina_yellow.webp") if "furina_yellow.webp" else create_empty_image(),
+    Image.open("nilou_blue.webp") if "nilou_blue.webp" else create_empty_image(),
+    create_empty_image(),  # Layer 3 is an empty image
+    create_empty_image()   # Layer 4 is an empty image
+]
+example_alphas = [1.0, 1.0, 1.0, 1.0]  # Example transparency values
+example_positions = [(101, 0), (264, 0), (0, 0), (0, 0)]  # Example positions
+example_crop_x = (160, 850)  # Example X-axis crop range
+example_crop_y = (360, 1020)  # Example Y-axis crop range
+
+# Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("## 🎨 Layer Overlay Application")
+    gr.Markdown("Upload multiple semi-transparent layers (PNG format), set transparency and position, and generate the overlayed image.")
+
+    with gr.Row():
+        # Left column: Inputs
+        with gr.Column():
+            gr.Markdown("### Upload Layers")
+            image1 = gr.Image(label="Layer 1", type="pil", image_mode="RGBA")
+            image2 = gr.Image(label="Layer 2", type="pil", image_mode="RGBA")
+            image3 = gr.Image(label="Layer 3", type="pil", image_mode="RGBA")
+            image4 = gr.Image(label="Layer 4", type="pil", image_mode="RGBA")
+
+            gr.Markdown("### Set Transparency")
+            alpha1 = gr.Slider(0, 1, value=1, label="Layer 1 Transparency")
+            alpha2 = gr.Slider(0, 1, value=1, label="Layer 2 Transparency")
+            alpha3 = gr.Slider(0, 1, value=1, label="Layer 3 Transparency")
+            alpha4 = gr.Slider(0, 1, value=1, label="Layer 4 Transparency")
+
+            gr.Markdown("### Set Positions")
+            with gr.Row():
+                x1 = gr.Slider(0, 512, value=0, label="Layer 1 X Position")
+                y1 = gr.Slider(0, 512, value=0, label="Layer 1 Y Position")
+            with gr.Row():
+                x2 = gr.Slider(0, 512, value=0, label="Layer 2 X Position")
+                y2 = gr.Slider(0, 512, value=0, label="Layer 2 Y Position")
+            with gr.Row():
+                x3 = gr.Slider(0, 512, value=0, label="Layer 3 X Position")
+                y3 = gr.Slider(0, 512, value=0, label="Layer 3 Y Position")
+            with gr.Row():
+                x4 = gr.Slider(0, 512, value=0, label="Layer 4 X Position")
+                y4 = gr.Slider(0, 512, value=0, label="Layer 4 Y Position")
+
+            gr.Markdown("### Set Crop Range")
+            with gr.Row():
+                crop_x_min = gr.Slider(0, 1024, value=0, label="X-axis Crop Start")
+                crop_x_max = gr.Slider(0, 1024, value=1024, label="X-axis Crop End")
+            with gr.Row():
+                crop_y_min = gr.Slider(0, 1024, value=0, label="Y-axis Crop Start")
+                crop_y_max = gr.Slider(0, 1024, value=1024, label="Y-axis Crop End")
+
+            run_button = gr.Button("Generate Overlayed Image")
+
+        # Right column: Outputs
+        with gr.Column():
+            gr.Markdown("### Overlay Results")
+            transparent_output = gr.Image(label="Overlayed Image (Transparent Background)", type="pil")
+            black_output = gr.Image(label="Overlayed Image (Black Background)", type="pil")
+            gr.Markdown("### Individual Layer Images")
+            layer1_image = gr.Image(label="Layer 1 Image", type="pil")
+            layer2_image = gr.Image(label="Layer 2 Image", type="pil")
+            layer3_image = gr.Image(label="Layer 3 Image", type="pil")
+            layer4_image = gr.Image(label="Layer 4 Image", type="pil")
+
+    # Bind events
+    run_button.click(
+        update_output,
+        inputs=[
+            image1, image2, image3, image4,  # Images
+            alpha1, alpha2, alpha3, alpha4,  # Transparency
+            x1, y1, x2, y2, x3, y3, x4, y4,  # Positions
+            crop_x_min, crop_x_max,  # X-axis crop range
+            crop_y_min, crop_y_max   # Y-axis crop range
+        ],
+        outputs=[transparent_output, black_output, layer1_image, layer2_image, layer3_image, layer4_image]
+    )
+
+    # Add examples
+    gr.Examples(
+        examples=[
+            [
+                example_images[0], example_images[1], example_images[2], example_images[3],  # Images
+                example_alphas[0], example_alphas[1], example_alphas[2], example_alphas[3],  # Transparency
+                example_positions[0][0], example_positions[0][1],  # Layer 1 position
+                example_positions[1][0], example_positions[1][1],  # Layer 2 position
+                example_positions[2][0], example_positions[2][1],  # Layer 3 position
+                example_positions[3][0], example_positions[3][1],  # Layer 4 position
+                example_crop_x[0], example_crop_x[1],  # X-axis crop range
+                example_crop_y[0], example_crop_y[1]   # Y-axis crop range
+            ]
+        ],
+        inputs=[
+            image1, image2, image3, image4,  # Images
+            alpha1, alpha2, alpha3, alpha4,  # Transparency
+            x1, y1, x2, y2, x3, y3, x4, y4,  # Positions
+            crop_x_min, crop_x_max,  # X-axis crop range
+            crop_y_min, crop_y_max   # Y-axis crop range
+        ],
+        outputs=[transparent_output, black_output, layer1_image, layer2_image, layer3_image, layer4_image],
+        fn=update_output,
+        cache_examples=True
+    )
+
+# Launch the application
+if __name__ == "__main__":
+    demo.launch(share=True)