.

app.py

@@ -56,17 +56,82 @@ with gr.Blocks() as demo:
             )
 
         with gr.TabItem("Edit your Banner"):
-            input_image_editor_component = gr.ImageEditor(
-                label='Image',
-                type='pil',
-                sources=["upload", "webcam"],
-                image_mode='RGB',
-                layers=False,
-                brush=gr.Brush(colors=["#FFFFFF"], color_mode="fixed"))
-            prompt = gr.Textbox(label="Enter the text to get a good start")
-            out_img=gr.Image()
-            btn = gr.Button()
-            btn.click(Banner.Image2Image, [prompt,input_image_editor_component], out_img)
+            with gr.Row():
+                with gr.Column():
+                    input_image_editor_component = gr.ImageEditor(
+                        label='Image',
+                        type='pil',
+                        sources=["upload", "webcam"],
+                        image_mode='RGB',
+                        layers=False,
+                        brush=gr.Brush(colors=["#FFFFFF"], color_mode="fixed"))
+
+                    with gr.Row():
+                        input_text_component = gr.Text(
+                            label="Prompt",
+                            show_label=False,
+                            max_lines=1,
+                            placeholder="Enter your prompt",
+                            container=False,
+                        )
+                        submit_button_component = gr.Button(
+                            value='Submit', variant='primary', scale=0)
+
+                    with gr.Accordion("Advanced Settings", open=False):
+                        seed_slicer_component = gr.Slider(
+                            label="Seed",
+                            minimum=0,
+                            maximum=MAX_SEED,
+                            step=1,
+                            value=42,
+                        )
+
+                        randomize_seed_checkbox_component = gr.Checkbox(
+                            label="Randomize seed", value=True)
+
+                        with gr.Row():
+                            strength_slider_component = gr.Slider(
+                                label="Strength",
+                                info="Indicates extent to transform the reference `image`. "
+                                    "Must be between 0 and 1. `image` is used as a starting "
+                                    "point and more noise is added the higher the `strength`.",
+                                minimum=0,
+                                maximum=1,
+                                step=0.01,
+                                value=0.85,
+                            )
+
+                            num_inference_steps_slider_component = gr.Slider(
+                                label="Number of inference steps",
+                                info="The number of denoising steps. More denoising steps "
+                                    "usually lead to a higher quality image at the",
+                                minimum=1,
+                                maximum=50,
+                                step=1,
+                                value=20,
+                            )
+                with gr.Column():
+                    output_image_component = gr.Image(
+                        type='pil', image_mode='RGB', label='Generated image', format="png")
+                    with gr.Accordion("Debug", open=False):
+                        output_mask_component = gr.Image(
+                            type='pil', image_mode='RGB', label='Input mask', format="png")
+            with gr.Row():
+                submit_button_component.click(
+                    fn=Banner.Image2Image,
+                    inputs=[
+                        input_image_editor_component,
+                        input_text_component,
+                        seed_slicer_component,
+                        randomize_seed_checkbox_component,
+                        strength_slider_component,
+                        num_inference_steps_slider_component
+                    ],
+                    outputs=[
+                        output_image_component,
+                        output_mask_component
+                    ]
+                )
 
         with gr.TabItem("Upgrade your Banner"):
             img = gr.Image()

options/Banner.py

@@ -8,8 +8,17 @@ def TextImage(prompt, width=1024, height=1024, guidance_scale=3.5,
     img = T2I(prompt, width, height, guidance_scale, num_inference_steps)
     return img
 
-def Image2Image(prompt,image):
-    return I2I(image, prompt)
+# def Image2Image(prompt,image):
+#     return I2I(image, prompt)
+
+def Image2Image(
+    input_image_editor: dict,
+    input_text: str,
+    seed_slicer: int,
+    randomize_seed_checkbox: bool,
+    strength_slider: float,
+    num_inference_steps_slider: int,
+):return I2I(input_image_editor,input_text,seed_slicer,randomize_seed_checkbox,strength_slider,num_inference_steps_slider)
 
 def Image2Image_2(prompt,image,size,num_inference_steps=30):
     return I2I_2(image, prompt,size,num_inference_steps)

options/Banner_Model/Image2Image.py

@@ -1,38 +1,23 @@
-import imageio
+from typing import Tuple
+
+import requests
+import random,os
 import numpy as np
+import gradio as gr
+import spaces
+import torch
 from PIL import Image
-import torch,random
-# from .controlnet_flux import FluxControlNetModel
-# from .transformer_flux import FluxTransformer2DModel
-# from .pipeline_flux_controlnet_inpaint import FluxControlNetInpaintingPipeline
-from typing import Tuple
 from diffusers import FluxInpaintPipeline
-import gradio as gr
-
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"Using device for I2I: {DEVICE}")
+from huggingface_hub import login
+login(token=os.getenv("TOKEN"))
 
-# # Load the inpainting pipeline
-
-# def resize_image(image, height, width):
-#     """Resize image tensor to the desired height and width."""
-#     return torch.nn.functional.interpolate(image, size=(height, width), mode='nearest')
-
-
-# def dummy(img):
-#     """Save the composite image and generate a mask from the alpha channel."""
-#     imageio.imwrite("output_image.png", img["composite"])
-
-#     # Extract alpha channel from the first layer to create the mask
-#     alpha_channel = img["layers"][0][:, :, 3]
-#     mask = np.where(alpha_channel == 0, 0, 255).astype(np.uint8)
-
-#     return img["background"], mask
 MAX_SEED = np.iinfo(np.int32).max
+IMAGE_SIZE = 1024
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
 def resize_image_dimensions(
     original_resolution_wh: Tuple[int, int],
-    maximum_dimension: int = 1024
+    maximum_dimension: int = IMAGE_SIZE
 ) -> Tuple[int, int]:
     width, height = original_resolution_wh
 
@@ -55,20 +40,19 @@ def resize_image_dimensions(
     return new_width, new_height
 
 
-# @spaces.GPU(duration=100)
+@spaces.GPU(duration=100)
 def I2I(
-    input_image_editor,
+    input_image_editor: dict,
     input_text: str,
-    seed_slicer: int=42,
-    randomize_seed_checkbox: bool=True,
-    strength_slider: float=0.85,
-    num_inference_steps_slider: int=20,
-    progress=gr.Progress(track_tqdm=True)):
-    pipe = FluxInpaintPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16).to(DEVICE)
+    seed_slicer: int,
+    randomize_seed_checkbox: bool,
+    strength_slider: float,
+    num_inference_steps_slider: int,
+    progress=gr.Progress(track_tqdm=True)
+):
     if not input_text:
         gr.Info("Please enter a text prompt.")
         return None, None
-    print(type(input_image_editor),input_image_editor)
 
     image = input_image_editor['background']
     mask = input_image_editor['layers'][0]
@@ -80,6 +64,9 @@ def I2I(
     if not mask:
         gr.Info("Please draw a mask on the image.")
         return None, None
+    
+    pipe = FluxInpaintPipeline.from_pretrained(
+    "black-forest-labs/FLUX.1-dev", torch_dtype=torch.bfloat16).to(DEVICE)
 
     width, height = resize_image_dimensions(original_resolution_wh=image.size)
     resized_image = image.resize((width, height), Image.LANCZOS)
@@ -99,63 +86,4 @@ def I2I(
         num_inference_steps=num_inference_steps_slider
     ).images[0]
     print('INFERENCE DONE')
-    imageio.imwrite("output_image.png", result)
-    return result
-
-def remove_background(image: Image.Image, threshold: int = 50) -> Image.Image:
-    image = image.convert("RGBA")
-    data = image.getdata()
-    new_data = []
-    for item in data:
-        avg = sum(item[:3]) / 3
-        if avg < threshold:
-            new_data.append((0, 0, 0, 0))
-        else:
-            new_data.append(item)
-
-    image.putdata(new_data)
-    return image
-
-
-# def I2I(prompt, image, width=1024, height=1024, guidance_scale=8.0, num_inference_steps=20, strength=0.99):
-    
-#     controlnet = FluxControlNetModel.from_pretrained("alimama-creative/FLUX.1-dev-Controlnet-Inpainting-Alpha", torch_dtype=torch.bfloat16)
-#     transformer = FluxTransformer2DModel.from_pretrained(
-#             "black-forest-labs/FLUX.1-dev", subfolder='transformer', torch_dytpe=torch.bfloat16
-#         )
-#     pipe = FluxControlNetInpaintingPipeline.from_pretrained(
-#         "black-forest-labs/FLUX.1-dev",
-#         controlnet=controlnet,
-#         transformer=transformer,
-#         torch_dtype=torch.bfloat16
-#     ).to(device)
-#     pipe.transformer.to(torch.bfloat16)
-#     pipe.controlnet.to(torch.bfloat16)
-#     pipe.set_attn_processor(FluxAttnProcessor2_0())
-
-
-#     img_url, mask = dummy(image)
-
-#     # Resize image and mask to the target dimensions (height x width)
-#     img_url = Image.fromarray(img_url, mode="RGB").resize((width, height))
-#     mask_url = Image.fromarray(mask,mode="L").resize((width, height))
-
-#     # Make sure both image and mask are converted into correct tensors
-#     generator = torch.Generator(device=device).manual_seed(0)
-
-#     # Generate the inpainted image
-#     result = pipe(
-#         prompt=prompt,
-#         height=size[1],
-#         width=size[0],
-#         control_image=image,
-#         control_mask=mask,
-#         num_inference_steps=28,
-#         generator=generator,
-#         controlnet_conditioning_scale=0.9,
-#         guidance_scale=3.5,
-#         negative_prompt="",
-#         true_guidance_scale=3.5
-#         ).images[0]
-
-#     return result
+    return result, resized_mask