Update app.py

app.py

@@ -366,26 +366,76 @@ LOADED_ADAPTERS = set()
 # Helpers: resolution
 # ============================================================
 
+# We prefer *area-based* sizing (≈ megapixels) over long-edge sizing.
+# This aligns better with Qwen-Image-Edit's internal assumptions and reduces FOV drift.
 
-def _round8(x: int) -> int:
-    return max(8, (int(x) // 8) * 8)
+def _round_to_multiple(x: int, m: int) -> int:
+    return max(m, (int(x) // m) * m)
 
+def compute_canvas_dimensions_from_area(
+    image: Image.Image,
+    target_area: int,
+    multiple_of: int,
+) -> tuple[int, int]:
+    """Compute (width, height) that matches image aspect ratio and approximates target_area.
 
-def compute_dimensions(image: Image.Image, long_edge: int) -> tuple[int, int]:
+    The result is floored to be divisible by multiple_of (typically vae_scale_factor*2).
+    """
     w, h = image.size
-    if w >= h:
-        new_w = long_edge
-        new_h = int(round(long_edge * (h / w)))
-    else:
-        new_h = long_edge
-        new_w = int(round(long_edge * (w / h)))
-    return _round8(new_w), _round8(new_h)
+    aspect = w / h if h else 1.0
+
+    # Use the pipeline's own area->(w,h) helper for consistency.
+    from qwenimage.pipeline_qwenimage_edit_plus import calculate_dimensions
+
+    width, height = calculate_dimensions(int(target_area), float(aspect))
+    width = _round_to_multiple(int(width), int(multiple_of))
+    height = _round_to_multiple(int(height), int(multiple_of))
+    return width, height
+
+def get_target_area_for_lora(
+    image: Image.Image,
+    lora_adapter: str,
+    user_target_megapixels: float,
+) -> int:
+    """Return target pixel area for the canvas.
+
+    Priority:
+      1) Adapter spec: target_area (pixels) or target_megapixels
+      2) Adapter spec: target_long_edge (legacy) -> converted to area using image aspect
+      3) User slider target megapixels
+    """
+    spec = ADAPTER_SPECS.get(lora_adapter, {})
 
+    if "target_area" in spec:
+        try:
+            return int(spec["target_area"])
+        except Exception:
+            pass
 
-def get_target_long_edge_for_lora(lora_adapter: str) -> int:
-    spec = ADAPTER_SPECS.get(lora_adapter, {})
-    return int(spec.get("target_long_edge", 1024))
+    if "target_megapixels" in spec:
+        try:
+            mp = float(spec["target_megapixels"])
+            return int(mp * 1024 * 1024)
+        except Exception:
+            pass
 
+    # Legacy support (e.g. Upscale2K)
+    if "target_long_edge" in spec:
+        try:
+            long_edge = int(spec["target_long_edge"])
+            w, h = image.size
+            if w >= h:
+                new_w = long_edge
+                new_h = int(round(long_edge * (h / w)))
+            else:
+                new_h = long_edge
+                new_w = int(round(long_edge * (w / h)))
+            return int(new_w * new_h)
+        except Exception:
+            pass
+
+    # User default
+    return int(float(user_target_megapixels) * 1024 * 1024)
 
 # ============================================================
 # Helpers: multi-input routing + gallery normalization
@@ -702,7 +752,7 @@ def _ensure_loaded_and_get_active_adapters(selected_lora: str):
 # ============================================================
 
 
-def on_lora_change_ui(selected_lora, current_prompt):
+def on_lora_change_ui(selected_lora, current_prompt, current_extras_condition_only):
     # Preset prompt (fill only if empty)
     if selected_lora != NONE_LORA:
         preset = LORA_PRESET_PROMPTS.get(selected_lora, "")
@@ -719,7 +769,14 @@ def on_lora_change_ui(selected_lora, current_prompt):
     else:
         img2_update = gr.update(visible=False, value=None, label="Upload Reference (Image 2)")
 
-    return prompt_update, img2_update
+    # Extra references routing default:
+    # For BFS/AnyPose-like adapters, it's usually safer to keep extra refs as conditioning-only.
+    if selected_lora in ("BFS-Best-FaceSwap", "BFS-Best-FaceSwap-merge", "AnyPose"):
+        extras_update = gr.update(value=True)
+    else:
+        extras_update = gr.update(value=current_extras_condition_only)
+
+    return prompt_update, img2_update, extras_update
 
 
 # ============================================================
@@ -738,6 +795,9 @@ def infer(
     randomize_seed,
     guidance_scale,
     steps,
+    target_megapixels,
+    extras_condition_only,
+    pad_to_canvas,
     progress=gr.Progress(track_tqdm=True),
 ):
     gc.collect()
@@ -791,15 +851,30 @@ def infer(
         pipe_images = pipe_images[0]
 
     # Resolution derived from Image 1 (base/body/target)
-    target_long_edge = get_target_long_edge_for_lora(lora_adapter)
-    width, height = compute_dimensions(img1, target_long_edge)
+    # Use target *area* (≈ megapixels) rather than long-edge sizing to reduce FOV drift.
+    target_area = get_target_area_for_lora(img1, lora_adapter, float(target_megapixels))
+    width, height = compute_canvas_dimensions_from_area(
+        img1,
+        target_area=target_area,
+        multiple_of=int(pipe.vae_scale_factor * 2),
+    )
+
+    # Decide which images participate in the VAE latent stream.
+    # If enabled, extra references beyond (Img_1, Img_2) become conditioning-only.
+    vae_image_indices = None
+    if extras_condition_only:
+        if isinstance(pipe_images, list) and len(pipe_images) > 2:
+            vae_image_indices = [0, 1] if len(pipe_images) >= 2 else [0]
 
     try:
         print(
              "[DEBUG][infer] submitting request | "
-             f"lora_adapter={lora_adapter!r} seed={seed} prompt={prompt!r}"
+             f"lora_adapter={lora_adapter!r} seed={seed} prompt={prompt!r} "
+             f"canvas={width}x{height} target_area={target_area} "
+             f"extras_condition_only={extras_condition_only} vae_image_indices={vae_image_indices} "
+             f"pad_to_canvas={bool(pad_to_canvas)}"
         )
-        
+
         result = pipe(
             image=pipe_images,
             prompt=prompt,
@@ -809,6 +884,8 @@ def infer(
             num_inference_steps=steps,
             generator=generator,
             true_cfg_scale=guidance_scale,
+            vae_image_indices=vae_image_indices,
+            pad_to_canvas=bool(pad_to_canvas),
         ).images[0]
         return result, seed
     finally:
@@ -825,7 +902,7 @@ def infer_example(input_image, prompt, lora_adapter):
     guidance_scale = 1.0
     steps = 4
     # Examples don't supply Image 2 or extra images; and example list doesn't include AnyPose/BFS.
-    result, seed = infer(input_pil, None, None, prompt, lora_adapter, 0, True, guidance_scale, steps)
+    result, seed = infer(input_pil, None, None, prompt, lora_adapter, 0, True, guidance_scale, steps, 1.0, True, True)
     return result, seed
 
 
@@ -894,12 +971,27 @@ with gr.Blocks() as demo:
                     randomize_seed = gr.Checkbox(label="Randomize Seed", value=True)
                     guidance_scale = gr.Slider(label="Guidance Scale", minimum=1.0, maximum=10.0, step=0.1, value=1.0)
                     steps = gr.Slider(label="Inference Steps", minimum=1, maximum=50, step=1, value=4)
+                    target_megapixels = gr.Slider(
+                        label="Target Megapixels (canvas)",
+                        minimum=0.5,
+                        maximum=6.0,
+                        step=0.1,
+                        value=1.0,
+                    )
+                    extras_condition_only = gr.Checkbox(
+                        label="Extra references are conditioning-only (exclude from VAE)",
+                        value=True,
+                    )
+                    pad_to_canvas = gr.Checkbox(
+                        label="Pad images to canvas aspect (avoid warping)",
+                        value=True,
+                    )
 
-        # On LoRA selection: preset prompt + toggle Image 2
+        # On LoRA selection: preset prompt + toggle Image 2 + default extras routing
         lora_adapter.change(
             fn=on_lora_change_ui,
-            inputs=[lora_adapter, prompt],
-            outputs=[prompt, input_image_2],
+            inputs=[lora_adapter, prompt, extras_condition_only],
+            outputs=[prompt, input_image_2, extras_condition_only],
         )
 
         gr.Examples(
@@ -948,6 +1040,9 @@ with gr.Blocks() as demo:
             randomize_seed,
             guidance_scale,
             steps,
+            target_megapixels,
+            extras_condition_only,
+            pad_to_canvas,
         ],
         outputs=[output_image, seed],
     )