Update engine.py

engine.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 import gc
 import io
+import logging
 import os
 import threading
 from dataclasses import dataclass
@@ -1181,6 +1182,7 @@ def apply_outfit(
         # Collar should sit at the shoulder line, not above/below it —
         # use the shoulder keypoints' own y as the collar target.
         target_collar_y = shoulders.center_y
+        _outfit_debug_source = "pose"
     else:
         # Fallback: derive an approximate shoulder position from the
         # already-known face box, since we always have that.
@@ -1190,6 +1192,7 @@ def apply_outfit(
         # same order-of-magnitude approximation used elsewhere in this
         # file for anatomy without a direct measurement.
         target_collar_y = face.y + face.h * 1.9
+        _outfit_debug_source = "fallback"
 
     scale = target_width_px / garment.shoulder_width_px
     new_w = max(1, int(round(garment.image.width * scale)))
@@ -1203,6 +1206,16 @@ def apply_outfit(
     paste_x = int(round(target_cx - scaled_collar_x))
     paste_y = int(round(target_collar_y - scaled_collar_y))
 
+    logging.getLogger("passport-maker").info(
+        "apply_outfit: source=%s shoulders_conf=%.2f target_width=%.0f "
+        "target_cx=%.0f target_collar_y=%.0f scale=%.3f garment_size=%dx%d "
+        "paste=(%d,%d) canvas=%dx%d",
+        _outfit_debug_source,
+        shoulders.confidence if shoulders else -1.0,
+        target_width_px, target_cx, target_collar_y, scale,
+        new_w, new_h, paste_x, paste_y, matted.width, matted.height,
+    )
+
     # Composite: start from a copy of matted, paste garment on top (using
     # its own alpha as the mask so transparent garment-PNG pixels don't
     # overwrite the subject), THEN paste the original head/shoulders
@@ -1213,20 +1226,51 @@ def apply_outfit(
     del scaled_garment
     gc.collect()
 
-    # Re-apply the original face region on top. Padding matches the
-    # face-thumbnail crop elsewhere in this file (0.6x face size margin)
-    # so the reinstated patch comfortably covers the whole head with a
-    # soft-enough boundary that a hard rectangle edge is unlikely to fall
-    # across a hairline in a way that reads as an obvious seam.
-    pad = int(max(face.w, face.h) * 0.6)
+    # Re-apply the original face region on top — but ONLY the face itself,
+    # not a large margin around it. A prior version used a 2.2x-face-size
+    # square patch (matching the display-only face-thumbnail crop
+    # elsewhere in this file), which was large enough to reach down into
+    # the collar/upper-chest area and paste the person's ORIGINAL shirt
+    # collar right back over the garment that was just composited —
+    # silently undoing the outfit swap every time. This tighter patch
+    # (1.3x face size, elliptical mask) covers face + hair with margin to
+    # spare, but stops well above where any garment's collar sits.
+    pad = int(max(face.w, face.h) * 0.15)
     side = max(face.w, face.h) + 2 * pad
     fx0 = max(0, int(face.cx - side / 2))
     fy0 = max(0, int(face.cy - side / 2))
     fx1 = min(matted.width, fx0 + side)
     fy1 = min(matted.height, fy0 + side)
     face_patch = matted.crop((fx0, fy0, fx1, fy1))
-    result.paste(face_patch, (fx0, fy0), face_patch)
-    del face_patch
+
+    # Elliptical alpha mask instead of the patch's own (rectangular) alpha
+    # — softens the boundary so reinstating the face doesn't leave a
+    # visible hard-edged square over the garment's shoulder area, and
+    # keeps the effective coverage smaller than the crop box itself
+    # (an ellipse inscribed in the square touches the collar line at far
+    # fewer pixels than the square's bottom edge would). Combined with
+    # the patch's own alpha (multiply, both 0-255) so background pixels
+    # that were already transparent in the matte stay transparent rather
+    # than the ellipse forcing them opaque.
+    from PIL import ImageDraw as _ImageDraw
+    import numpy as _np
+
+    ellipse_mask = Image.new("L", face_patch.size, 0)
+    _ImageDraw.Draw(ellipse_mask).ellipse([0, 0, face_patch.size[0], face_patch.size[1]], fill=255)
+
+    if face_patch.mode == "RGBA":
+        orig_alpha = face_patch.split()[3]
+        combined_arr = (
+            _np.array(ellipse_mask, dtype=_np.uint16)
+            * _np.array(orig_alpha, dtype=_np.uint16)
+            // 255
+        ).astype(_np.uint8)
+        combined_mask = Image.fromarray(combined_arr, mode="L")
+    else:
+        combined_mask = ellipse_mask
+
+    result.paste(face_patch, (fx0, fy0), combined_mask)
+    del face_patch, ellipse_mask, combined_mask
     gc.collect()
 
     return result
@@ -1245,10 +1289,10 @@ def process_photo(
     y_offset: float = 0.0,
     auto_straighten: bool = True,
     outfit_label: Optional[str] = None,
-) -> tuple[Image.Image, Optional[Image.Image], list["ComplianceCheck"], Image.Image, Image.Image, float]:
+) -> tuple[Image.Image, Optional[Image.Image], list["ComplianceCheck"], Image.Image, Image.Image, float, bool, Optional[str]]:
     """Full pipeline. Returns (single_photo, print_sheet_or_None,
     compliance_checks, bg_removed_preview, face_only_thumbnail,
-    straighten_angle_applied).
+    straighten_angle_applied, outfit_applied, outfit_error).
 
     bg_removed_preview: the alpha-matted subject on transparent background,
     at the same size as `bounded` — this is a display artifact for the UI's
@@ -1271,6 +1315,17 @@ def process_photo(
     None/"" to skip outfit overlay entirely (default — the original
     photo's clothing is used, exactly as before this feature existed).
 
+    outfit_applied: True only if outfit compositing genuinely succeeded.
+    False whenever outfit_label was set but compositing failed and the
+    pipeline silently fell back to the original photo — the caller MUST
+    check this rather than assuming outfit_label being set means the
+    photo was actually outfitted, since that assumption previously
+    produced a status message claiming an outfit was applied when it
+    silently wasn't.
+
+    outfit_error: short error string when outfit_applied is False due to
+    a failure (None if no outfit was requested, or if it succeeded).
+
     Raises ValueError with a user-facing message on any recoverable
     failure (no face found, bad spec key, etc) — ui.py surfaces these via
     gr.Error rather than letting a raw traceback reach the user.
@@ -1317,18 +1372,32 @@ def process_photo(
     # requested, skip entirely: zero cost, zero behavior change from
     # before this feature existed.
     outfitted = None
+    outfit_applied = False
+    outfit_error: Optional[str] = None
     if outfit_label:
         try:
             outfitted = apply_outfit(bounded, matted, face, outfit_label)
+            outfit_applied = True
         except ValueError:
             raise  # unknown garment label — genuine user-facing error
-        except Exception:
+        except Exception as e:
             # Pose detection or compositing failed for a reason that
             # isn't the user's fault (e.g. onnxruntime hiccup) — degrade
             # gracefully to the original photo rather than failing the
             # whole generate. Outfit overlay is an enhancement, not a
-            # core guarantee the way face detection is.
+            # core guarantee the way face detection is. BUT: log it for
+            # real, and tell the caller it silently degraded — an earlier
+            # version of this code swallowed the exception AND still
+            # reported "outfit: X" in the UI status line, which lied to
+            # the user about what actually happened to their photo.
+            import traceback
+            logging.getLogger("passport-maker").warning(
+                "Outfit overlay failed, falling back to original photo: %s",
+                traceback.format_exc(),
+            )
             outfitted = None
+            outfit_applied = False
+            outfit_error = str(e) or type(e).__name__
 
     del bounded
     gc.collect()
@@ -1368,7 +1437,7 @@ def process_photo(
     if paper_key:
         sheet = build_print_sheet(final_photo, spec, paper_key)
 
-    return final_photo, sheet, checks, bg_removed_preview, face_thumb, straighten_angle_applied
+    return final_photo, sheet, checks, bg_removed_preview, face_thumb, straighten_angle_applied, outfit_applied, outfit_error
 
 
 MAX_BATCH_SIZE = 10  # cap: each image is a separate @spaces.GPU acquisition
@@ -1411,7 +1480,7 @@ def process_batch(
     results: list[BatchResult] = []
     for filename, img in images:
         try:
-            photo, _sheet, _checks, _bg_preview, _face_thumb, _angle = process_photo(
+            photo, _sheet, _checks, _bg_preview, _face_thumb, _angle, _outfit_ok, _outfit_err = process_photo(
                 image=img,
                 spec_key=spec_key,
                 bg_hex=bg_hex,