Spaces:
Running
Running
| 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("芙宁娜_yellow.webp") if "芙宁娜_yellow.webp" else create_empty_image(), | |
| Image.open("妮露_blue.webp") if "妮露_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) |