Push

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -1,13 +1,33 @@
 ---
-title: FLUX.1 Fill Dev
-emoji: 🖌️
+title: AnyFurnish
+emoji: 🛋️
 colorFrom: green
-colorTo: purple
+colorTo: yellow
 sdk: gradio
+python_version: 3.12
 sdk_version: 5.6.0
+suggested_hardware: a100-large
 app_file: app.py
-pinned: false
+fullWidth: true
+header: mini
+# models: blanchon/anyfurnish
+# datasets: blanchon/anyfurnish-dataset
+tags:
+  - image-generation
+  - image-to-image
+  - furniture
+  - virtual-staging
+  - home-decor
+  - home-design
+pinned: true
+preload_from_hub:
+ - xiaozaa/flux1-fill-dev-diffusers
+ - blanchon/FluxFillFurniture
+ - black-forest-labs/FLUX.1-Fill-dev
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AnyFurnish
+
+AnyFurnish is a tool that allows you to generate furniture images using Flux.1 Fill Dev.
+

app.py

@@ -1,111 +1,164 @@
+import secrets
+from typing import cast
+
 import gradio as gr
 import numpy as np
-
 import spaces
 import torch
-import spaces
-import random 
+from diffusers import FluxFillPipeline
+from gradio.components.image_editor import EditorValue
+from PIL import Image, ImageOps
 
-from diffusers import FluxFillPipeline, FluxTransformer2DModel
-from PIL import Image
+DEVICE = "cuda"
 
-device = "cuda"
 MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 2048
-
-# pipe = FluxFillPipeline.from_pretrained("black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16).to("cuda")
-transformer = FluxTransformer2DModel.from_pretrained(
-    "xiaozaa/flux1-fill-dev-diffusers",   ## The official Flux-Fill weights
-    torch_dtype=torch.bfloat16
-)
-print("Start loading LoRA weights")
-state_dict, network_alphas = FluxFillPipeline.lora_state_dict(
-    pretrained_model_name_or_path_or_dict="blanchon/FluxFillFurniture",
-    weight_name="pytorch_lora_weights3.safetensors",
-    return_alphas=True
-)
-is_correct_format = all("lora" in key or "dora_scale" in key for key in state_dict.keys())
-if not is_correct_format:
-    raise ValueError("Invalid LoRA checkpoint.")
-
-
-pipe = FluxFillPipeline.from_pretrained(
-    "black-forest-labs/FLUX.1-Fill-dev",
-    torch_dtype=torch.bfloat16
-).to(device)
-FluxFillPipeline.load_lora_into_transformer(
-    state_dict=state_dict,
-    network_alphas=network_alphas,
-    transformer=pipe.transformer,
-)
-
-# pipe.load_lora_weights("blanchon/FluxFillFurniture", weight_name="lora_fill.safetensors")
-# pipe.fuse_lora(lora_scale=1.0)
-pipe.to("cuda")
-
-def calculate_optimal_dimensions(image: Image.Image):
-    # Extract the original dimensions
-    original_width, original_height = image.size
-    
-    # Set constants for enforcing a roughly 2:1 aspect ratio
-    MIN_ASPECT_RATIO = 1.8
-    MAX_ASPECT_RATIO = 2.2
-    FIXED_DIMENSION = 1024
-
-    # Calculate the aspect ratio of the original image
-    original_aspect_ratio = original_width / original_height
-
-    # Determine which dimension to fix
-    if original_aspect_ratio > 1:  # Wider than tall
-        width = FIXED_DIMENSION
-        height = round(FIXED_DIMENSION / original_aspect_ratio)
-    else:  # Taller than wide
-        height = FIXED_DIMENSION
-        width = round(FIXED_DIMENSION * original_aspect_ratio)
+FIXED_DIMENSION = 900
+
+SYSTEM_PROMPT = r"""This two-panel split-frame image showcases a furniture in as a product shot versus styled in a room.
+[LEFT] standalone product shot image the furniture on a white background.
+[RIGHT] integrated example within a room scene."""
+
+if not torch.cuda.is_available():
+
+    def _dummy_pipe(image: Image.Image, *args, **kwargs):  # noqa: ARG001
+        return {"images": [image]}
+
+    pipe = _dummy_pipe
+else:
+    state_dict, network_alphas = FluxFillPipeline.lora_state_dict(
+        pretrained_model_name_or_path_or_dict="blanchon/FluxFillFurniture",
+        weight_name="pytorch_lora_weights3.safetensors",
+        return_alphas=True,
+    )
+
+    if not all(("lora" in key or "dora_scale" in key) for key in state_dict):
+        msg = "Invalid LoRA checkpoint."
+        raise ValueError(msg)
+
+    pipe = FluxFillPipeline.from_pretrained(
+        "black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16
+    ).to(DEVICE)
+    FluxFillPipeline.load_lora_into_transformer(
+        state_dict=state_dict,
+        network_alphas=network_alphas,
+        transformer=pipe.transformer,
+    )
+    pipe.to(DEVICE)
+
 
+def calculate_optimal_dimensions(image: Image.Image) -> tuple[int, int]:
+    width, height = image.size
     # Ensure dimensions are multiples of 8
     width = (width // 8) * 8
     height = (height // 8) * 8
 
-    # Enforce aspect ratio limits
-    calculated_aspect_ratio = width / height
-    if calculated_aspect_ratio > MAX_ASPECT_RATIO:
-        width = (height * MAX_ASPECT_RATIO // 8) * 8
-    elif calculated_aspect_ratio < MIN_ASPECT_RATIO:
-        height = (width / MIN_ASPECT_RATIO // 8) * 8
+    return int(width), int(height)
 
-    # Ensure width and height remain above the minimum dimensions
-    width = max(width, 576) if width == FIXED_DIMENSION else width
-    height = max(height, 576) if height == FIXED_DIMENSION else height
-
-    return width, height
 
 @spaces.GPU
-def infer(edit_images, prompt, seed=42, randomize_seed=False, width=1024, height=1024, guidance_scale=3.5, num_inference_steps=28, progress=gr.Progress(track_tqdm=True)):
-    image = edit_images["background"]
+def infer(
+    furniture_image: Image.Image,
+    room_image: EditorValue,
+    prompt,
+    seed=42,
+    randomize_seed=False,
+    guidance_scale=3.5,
+    num_inference_steps=28,
+    progress=gr.Progress(track_tqdm=True),  # noqa: ARG001, B008
+):
+    _room_image = room_image["background"]
+    if _room_image is None:
+        msg = "Room image is required"
+        raise ValueError(msg)
+    _room_image = cast(Image.Image, _room_image)
+    _room_image = ImageOps.fit(
+        _room_image,
+        (FIXED_DIMENSION, FIXED_DIMENSION),
+        method=Image.Resampling.LANCZOS,
+        centering=(0.5, 0.5),
+    )
+
+    _room_mask = room_image["layers"][0]
+    if _room_mask is None:
+        msg = "Room mask is required"
+        raise ValueError(msg)
+    _room_mask = cast(Image.Image, _room_mask)
+    _room_mask = ImageOps.fit(
+        _room_mask,
+        (FIXED_DIMENSION, FIXED_DIMENSION),
+        method=Image.Resampling.LANCZOS,
+        centering=(0.5, 0.5),
+    )
+
+    furniture_image = ImageOps.fit(
+        furniture_image,
+        (FIXED_DIMENSION, FIXED_DIMENSION),
+        method=Image.Resampling.LANCZOS,
+        centering=(0.5, 0.5),
+    )
+    _furniture_image = Image.new(
+        "RGB",
+        (FIXED_DIMENSION, FIXED_DIMENSION),
+        (255, 255, 255),
+    )
+    _furniture_image.paste(furniture_image, (0, 0))
+
+    _furniture_mask = Image.new(
+        "RGB", (FIXED_DIMENSION, FIXED_DIMENSION), (255, 255, 255)
+    )
+
+    image = Image.new(
+        "RGB",
+        (FIXED_DIMENSION * 2, FIXED_DIMENSION),
+        (255, 255, 255),
+    )
+    # Paste on the center of the image
+    image.paste(_furniture_image, (0, 0))
+    image.paste(_room_image, (FIXED_DIMENSION, 0))
+
+    mask = Image.new(
+        "RGB",
+        (FIXED_DIMENSION * 2, FIXED_DIMENSION),
+        (255, 255, 255),
+    )
+    mask.paste(_furniture_mask, (0, 0))
+    mask.paste(_room_mask, (FIXED_DIMENSION, 0))
+
     width, height = calculate_optimal_dimensions(image)
-    mask = edit_images["layers"][0]
+    # Resize the image and mask to the optimal dimensions for the VAe
+    image = image.resize((width, height))
+    mask = mask.resize((width, height))
+
     if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-    image = pipe(
-        prompt=prompt,
+        seed = secrets.randbelow(MAX_SEED)
+
+    results_images = pipe(
+        prompt=prompt + ".\n" + SYSTEM_PROMPT,
         image=image,
         mask_image=mask,
         height=height,
         width=width,
         guidance_scale=guidance_scale,
         num_inference_steps=num_inference_steps,
-        generator=torch.Generator("cpu").manual_seed(seed)
-    ).images[0]
-    return image, seed
-    
-examples = [
-    "a tiny astronaut hatching from an egg on the moon",
-    "a cat holding a sign that says hello world",
-    "an anime illustration of a wiener schnitzel",
-]
-
-css="""
+        batch_size=4,
+        generator=torch.Generator("cpu").manual_seed(seed),
+    )["images"]
+
+    cropped_images = [
+        image.crop((FIXED_DIMENSION, 0, FIXED_DIMENSION * 2, FIXED_DIMENSION))
+        for image in results_images
+    ]
+
+    return cropped_images, seed
+
+
+intro_markdown = """
+# AnyFurnish
+
+AnyFurnish is a tool that allows you to generate furniture images using Flux.1 Fill Dev.
+"""
+
+css = """
 #col-container {
     margin: 0 auto;
     max-width: 1000px;
@@ -113,23 +166,27 @@ css="""
 """
 
 with gr.Blocks(css=css) as demo:
-    
     with gr.Column(elem_id="col-container"):
-        gr.Markdown(f"""# FLUX.1 Fill [dev]
-12B param rectified flow transformer structural conditioning tuned, guidance-distilled from [FLUX.1 [pro]](https://blackforestlabs.ai/)  
-[[non-commercial license](https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/LICENSE.md)] [[blog](https://blackforestlabs.ai/announcing-black-forest-labs/)] [[model](https://huggingface.co/black-forest-labs/FLUX.1-dev)]
-        """)
+        gr.Markdown(intro_markdown)
         with gr.Row():
             with gr.Column():
-                edit_image = gr.ImageEditor(
-                    label='Upload and draw mask for inpainting',
-                    type='pil',
-                    sources=["upload", "webcam"],
-                    image_mode='RGB',
-                    layers=False,
-                    brush=gr.Brush(colors=["#FFFFFF"], color_mode="fixed"),
-                    height=600
-                )
+                with gr.Column():
+                    furniture_image = gr.Image(
+                        label="Furniture Image",
+                        type="pil",
+                        sources=["upload"],
+                        image_mode="RGB",
+                        height=300,
+                    )
+                    room_image = gr.ImageEditor(
+                        label="Room Image - Draw mask for inpainting",
+                        type="pil",
+                        sources=["upload"],
+                        image_mode="RGB",
+                        layers=False,
+                        brush=gr.Brush(colors=["#FFFFFF"], color_mode="fixed"),
+                        height=300,
+                    )
                 prompt = gr.Text(
                     label="Prompt",
                     show_label=False,
@@ -138,11 +195,17 @@ with gr.Blocks(css=css) as demo:
                     container=False,
                 )
                 run_button = gr.Button("Run")
-                
-            result = gr.Image(label="Result", show_label=False)
-        
+
+            results = gr.Gallery(
+                label="Results",
+                format="png",
+                show_label=False,
+                columns=2,
+                height=600,
+                preview=True,
+            )
+
         with gr.Accordion("Advanced Settings", open=False):
-            
             seed = gr.Slider(
                 label="Seed",
                 minimum=0,
@@ -150,31 +213,10 @@ with gr.Blocks(css=css) as demo:
                 step=1,
                 value=0,
             )
-            
+
             randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-            
-            with gr.Row():
-                
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,
-                    visible=False
-                )
-                
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,
-                    visible=False
-                )
-            
-            with gr.Row():
 
+            with gr.Row():
                 guidance_scale = gr.Slider(
                     label="Guidance Scale",
                     minimum=1,
@@ -182,7 +224,7 @@ with gr.Blocks(css=css) as demo:
                     step=0.5,
                     value=50,
                 )
-  
+
                 num_inference_steps = gr.Slider(
                     label="Number of inference steps",
                     minimum=1,
@@ -193,9 +235,17 @@ with gr.Blocks(css=css) as demo:
 
     gr.on(
         triggers=[run_button.click, prompt.submit],
-        fn = infer,
-        inputs = [edit_image, prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps],
-        outputs = [result, seed]
+        fn=infer,
+        inputs=[
+            furniture_image,
+            room_image,
+            prompt,
+            seed,
+            randomize_seed,
+            guidance_scale,
+            num_inference_steps,
+        ],
+        outputs=[results, seed],
     )
 
-demo.launch()
+demo.launch()

pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "flux-1-fill-dev"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "accelerate>=1.2.1",
+    "diffusers",
+    "gradio>=5.12.0",
+    "peft>=0.14.0",
+    "pillow>=11.1.0",
+    "safetensors>=0.5.2",
+    "sentencepiece>=0.2.0",
+    "spaces>=0.32.0",
+    "transformers>=4.48.0",
+]
+
+[tool.uv.sources]
+diffusers = { git = "https://github.com/huggingface/diffusers.git" }

requirements.txt

@@ -3,4 +3,7 @@ transformers
 accelerate
 safetensors
 sentencepiece
-peft
+peft
+gradio
+spaces
+pillow