Update app.py

app.py

@@ -1,5 +1,5 @@
 # --------------------------------------------------------------
-#  Qwen‑Image‑Edit‑2509 LoRA Demo – fixed‑aspect‑ratio version
+#  Qwen‑Image‑Edit‑2509 LoRA Demo – 100 % aspect‑ratio preservation
 # --------------------------------------------------------------
 import os
 import random
@@ -7,7 +7,7 @@ import numpy as np
 import torch
 import gradio as gr
 import spaces
-from PIL import Image, ImageOps
+from PIL import Image
 from typing import Iterable
 
 # --------------------  THEME  ---------------------------------
@@ -169,43 +169,51 @@ pipe.load_lora_weights(
 pipe.transformer.set_attn_processor(QwenDoubleStreamAttnProcessorFA3())
 
 # --------------------------------------------------------------
-#  Helper – keep aspect ratio, round down to a multiple of 8
+#  Helper – pad to a multiple of 8 (no resizing)
 # --------------------------------------------------------------
 DIVISIBLE_BY = 8
-MAX_SIDE      = 1024   # longest side the model can handle
+MAX_SIDE      = 1024   # the model cannot accept a side larger than this
 
-def _make_multiple(x: int, base: int = DIVISIBLE_BY) -> int:
-    """Round **down** to the nearest multiple of `base`."""
-    return (x // base) * base
+def _make_multiple_up(x: int, base: int = DIVISIBLE_BY) -> int:
+    """Round **up** to the nearest multiple of `base`."""
+    return ((x + base - 1) // base) * base
 
-def resize_for_pipe(pil_img: Image.Image) -> tuple[Image.Image, tuple[int, int]]:
+def pad_to_multiple_of_8(img: Image.Image):
     """
-    1️⃣  Scale the longer side to at most ``MAX_SIDE`` while preserving aspect‑ratio.
-    2️⃣  Round both dimensions **down** to a multiple of 8 (the model’s requirement).
-    3️⃣  Return the resized image *and* the original size so we can upscale back later.
+    Pad the image with black pixels so that *both* dimensions are a multiple of 8.
+    Returns:
+        padded_img   – the image that will be fed to the pipeline
+        crop_box    – the (left, top, right, bottom) box that later lets us
+                      crop the generation back to the original size.
     """
-    orig_w, orig_h = pil_img.size
+    w, h = img.size
 
-    # ---- 1️⃣ longest‑side scaling ---------------------------------------
-    if max(orig_w, orig_h) > MAX_SIDE:
-        if orig_w >= orig_h:                     # wide picture
+    # Clamp the size to the model's hard limit (1024). If the user uploads a
+    # bigger picture we simply down‑scale it proportionally *before* padding.
+    if max(w, h) > MAX_SIDE:
+        if w >= h:
             new_w = MAX_SIDE
-            new_h = int(orig_h * MAX_SIDE / orig_w)
-        else:                                    # tall picture
+            new_h = int(h * MAX_SIDE / w)
+        else:
             new_h = MAX_SIDE
-            new_w = int(orig_w * MAX_SIDE / orig_h)
-    else:
-        new_w, new_h = orig_w, orig_h
+            new_w = int(w * MAX_SIDE / h)
+        img = img.resize((new_w, new_h), Image.LANCZOS)
+        w, h = img.size
 
-    # ---- 2️⃣ round down to a multiple of 8 -----------------------------
-    new_w = _make_multiple(new_w)
-    new_h = _make_multiple(new_h)
+    pad_w = _make_multiple_up(w)
+    pad_h = _make_multiple_up(h)
 
-    # ---- 3️⃣ actual resize ---------------------------------------------
-    resized = pil_img.resize((new_w, new_h), Image.LANCZOS)
+    left   = (pad_w - w) // 2
+    top    = (pad_h - h) // 2
+    right  = left + w
+    bottom = top  + h
+
+    # create a black canvas and paste the original image in the centre
+    padded = Image.new("RGB", (pad_w, pad_h), (0, 0, 0))
+    padded.paste(img, (left, top))
+
+    return padded, (left, top, right, bottom)
 
-    # keep the original dimensions for the final upscale step
-    return resized, (orig_w, orig_h)
 
 # --------------------------------------------------------------
 #  Inference function (GPU‑bound)
@@ -223,7 +231,7 @@ def infer(
     steps,
     progress=gr.Progress(track_tqdm=True),
 ):
-    """Run a single edit – returns the edited image with the SAME aspect‑ratio."""
+    """Run a single edit – the output has exactly the same width×height as the upload."""
     if input_image is None:
         raise gr.Error("Please upload an image to edit.")
 
@@ -254,7 +262,7 @@ def infer(
 
     # ---------- Image preparation ----------
     original = input_image.convert("RGB")
-    pipe_input, original_sz = resize_for_pipe(original)   # <-- NEW helper
+    pipe_input, crop_box = pad_to_multiple_of_8(original)   # <-- NEW helper
 
     # ---------- Diffusion ----------
     result = pipe(
@@ -268,14 +276,15 @@ def infer(
         true_cfg_scale=guidance_scale,
     ).images[0]
 
-    # ---------- Upscale back to the exact user‑provided resolution ----------
-    final = result.resize(original_sz, Image.LANCZOS)
+    # ---------- Crop back to the *exact* original resolution ----------
+    final = result.crop(crop_box)               # remove the padding we added
+    final = final.resize(original.size, Image.LANCZOS)  # just in case rounding moved a pixel
 
     return final, seed
 
 
 # --------------------------------------------------------------
-#  Example helper (uses deterministic settings)
+#  Example helper (deterministic quick run)
 # --------------------------------------------------------------
 @spaces.GPU(duration=30)
 def infer_example(input_image, prompt, lora_adapter):
@@ -305,7 +314,7 @@ with gr.Blocks() as demo:
                     elem_id="main-title")
         gr.Markdown(
             "Edit images with a variety of LoRA adapters while preserving the "
-            "original aspect‑ratio (no unexpected cropping)."
+            "exact input resolution (no side‑cropping, no automatic resizing)."
         )
 
         with gr.Row(equal_height=True):