Upload folder using huggingface_hub

custom_nodes/plxr_deteriorate/__init__.py

@@ -0,0 +1,93 @@
+"""PLXR Deteriorate — apply the training-time synthetic degradation to an image.
+
+Wraps the recipe families from the qwen-edit-restore project's deteriorate.py
+(bundled as deteriorate_core.py) so a workflow can force-degrade an input
+before restoration, for testing / guaranteeing visible deterioration.
+"""
+
+import io
+import random
+
+import numpy as np
+import torch
+from PIL import Image
+
+from . import deteriorate_core as core
+
+_REMBG_SESSION = None
+
+
+def _person_mask_from_array(img01):
+    """Soft subject mask via rembg, from a float [H,W,3] array. None on failure."""
+    global _REMBG_SESSION
+    try:
+        from rembg import remove, new_session
+        if _REMBG_SESSION is None:
+            _REMBG_SESSION = new_session("u2net")
+        buf = io.BytesIO()
+        Image.fromarray(core.to_uint8(img01)).save(buf, format="PNG")
+        out = remove(buf.getvalue(), session=_REMBG_SESSION, only_mask=True)
+        m = np.asarray(Image.open(io.BytesIO(out)).convert("L"),
+                       dtype=np.float32) / 255.0
+        if m.shape != img01.shape[:2]:
+            import cv2
+            m = cv2.resize(m, (img01.shape[1], img01.shape[0]))
+        return m
+    except Exception as e:
+        print(f"[plxr_deteriorate] person mask failed ({e}); bg-blur ops degrade to global blur")
+        return None
+
+
+class PLXRDeteriorate:
+    CATEGORY = "image/plxr"
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "run"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "family": (["random", "atmospheric", "digital"],),
+                "severity_min": ("FLOAT", {"default": 0.35, "min": 0.0, "max": 1.0, "step": 0.05}),
+                "severity_max": ("FLOAT", {"default": 0.85, "min": 0.0, "max": 1.0, "step": 0.05}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 2**32 - 1}),
+                "use_person_mask": ("BOOLEAN", {"default": True}),
+            }
+        }
+
+    def run(self, image, family, severity_min, severity_max, seed, use_person_mask):
+        out = []
+        for b in range(image.shape[0]):
+            x0 = image[b].cpu().numpy().astype(np.float32)  # [H,W,C] 0..1
+            x0 = np.clip(x0[..., :3], 0.0, 1.0)
+
+            item_seed = seed + b
+            rng_np = np.random.default_rng(item_seed)
+            pyrng = random.Random(item_seed ^ 0xABCD)
+
+            class R:
+                uniform = staticmethod(pyrng.uniform)
+                choice = staticmethod(pyrng.choice)
+                random = staticmethod(pyrng.random)
+                normal = staticmethod(rng_np.normal)
+
+            lo, hi = sorted((severity_min, severity_max))
+            sev = pyrng.uniform(lo, hi)
+
+            fam = family
+            if fam == "random":
+                fam = pyrng.choice(["atmospheric", "digital"])
+            recipe = (core.recipe_atmospheric if fam == "atmospheric"
+                      else core.recipe_digital)
+
+            mask = _person_mask_from_array(x0) if use_person_mask else None
+            y, label = recipe(x0.copy(), R, sev, mask)
+            print(f"[plxr_deteriorate] applied {label} sev={sev:.2f} seed={item_seed}")
+            y = np.clip(y, 0.0, 1.0)
+            out.append(torch.from_numpy(y.astype(np.float32)))
+        return (torch.stack(out).to(image.device),)
+
+
+NODE_CLASS_MAPPINGS = {"PLXRDeteriorate": PLXRDeteriorate}
+NODE_DISPLAY_NAME_MAPPINGS = {"PLXRDeteriorate": "PLXR Deteriorate (restore-lora test)"}

custom_nodes/plxr_deteriorate/deteriorate_core.py

@@ -0,0 +1,473 @@
+#!/usr/bin/env python3
+"""
+Deterioration generator for the Qwen-Image-Edit restore LoRA dataset.
+
+Takes clean "instagram quality" photos and produces degraded control images
+spanning: slightly-soft instagram save -> hazy/faded low-contrast phone pic ->
+crushed, recompressed WhatsApp forward -> overprocessed (halo sharpening /
+heavy grain / fake portrait-mode background blur).
+
+Each source image gets N variants (default 2) with *forced-different* recipe
+families so the pair never looks alike:
+  v1 -> family A "atmospheric": haze veil, lifted blacks, bland/faded color,
+        cast, bloom/veiling flare, lens softness, light grain, jpeg
+  v2 -> family B "digital/processed", one of:
+        B1 grainy+compressed (downscale-upscale, strong grain, low jpeg)
+        B2 overprocessed (halo oversharpen, sat/contrast push, grain, jpeg)
+        B3 portrait-mode fail (background-only blur via person mask,
+           mild global softness, cast, jpeg)
+
+Outputs (same pixel size as source):
+  out/control/{stem}_v{k}.jpg   degraded input
+  out/target/{stem}_v{k}.jpg    clean target (copy of source, same name)
+
+Usage:
+  python deteriorate.py --src ../official_photos_dataset --out ./dataset \
+      --limit 20 --variants 2 --seed 1234 --sheets ./review_sheets
+"""
+
+import argparse
+import hashlib
+import io
+import os
+import random
+import sys
+
+import cv2
+import numpy as np
+from PIL import Image
+
+# rembg is only needed for the background-blur op; loaded lazily.
+_REMBG_SESSION = None
+
+
+# ----------------------------------------------------------------------------
+# helpers
+# ----------------------------------------------------------------------------
+
+def load_rgb(path):
+    with Image.open(path) as im:
+        return np.asarray(im.convert("RGB"), dtype=np.float32) / 255.0
+
+
+def to_uint8(x):
+    return (np.clip(x, 0.0, 1.0) * 255.0 + 0.5).astype(np.uint8)
+
+
+def gaussian(x, sigma):
+    if sigma <= 0:
+        return x
+    k = int(sigma * 6) | 1
+    return cv2.GaussianBlur(x, (k, k), sigma)
+
+
+def luma(x):
+    return x[..., 0] * 0.299 + x[..., 1] * 0.587 + x[..., 2] * 0.114
+
+
+def scale_of(x):
+    """Relative size factor so op strengths look similar at any resolution."""
+    return max(x.shape[0], x.shape[1]) / 1500.0
+
+
+def person_mask(path, shape):
+    """Soft [0,1] mask of the subject via rembg/u2net. None on failure."""
+    global _REMBG_SESSION
+    try:
+        from rembg import remove, new_session
+        if _REMBG_SESSION is None:
+            _REMBG_SESSION = new_session("u2net")
+        with open(path, "rb") as f:
+            out = remove(f.read(), session=_REMBG_SESSION, only_mask=True)
+        m = np.asarray(Image.open(io.BytesIO(out)).convert("L"),
+                       dtype=np.float32) / 255.0
+        if m.shape != shape[:2]:
+            m = cv2.resize(m, (shape[1], shape[0]))
+        return m
+    except Exception as e:
+        print(f"  [warn] person mask failed ({e}); skipping bg-blur op",
+              file=sys.stderr)
+        return None
+
+
+# ----------------------------------------------------------------------------
+# degradation ops (all take/return float32 RGB in [0,1])
+# ----------------------------------------------------------------------------
+
+def op_fade(x, rng, sev):
+    """Lifted blacks + reduced contrast: the faded/bland look."""
+    lift = rng.uniform(0.02, 0.13) * sev
+    ceil = 1.0 - rng.uniform(0.0, 0.05) * sev
+    x = x * (ceil - lift) + lift
+    c = 1.0 - rng.uniform(0.08, 0.30) * sev
+    return (x - 0.5) * c + 0.5
+
+
+def op_desaturate(x, rng, sev):
+    s = rng.uniform(0.12, 0.45) * sev
+    l = luma(x)[..., None]
+    return x * (1 - s) + l * s
+
+
+def op_cast(x, rng, sev):
+    """Random color cast: warm, cool, magenta or green."""
+    a = rng.uniform(0.03, 0.11) * sev
+    kind = rng.choice(["warm", "cool", "magenta", "green"])
+    g = {
+        "warm":    (1 + a, 1 + a * 0.35, 1 - a),
+        "cool":    (1 - a, 1 + a * 0.15, 1 + a),
+        "magenta": (1 + a * 0.7, 1 - a * 0.6, 1 + a * 0.7),
+        "green":   (1 - a * 0.5, 1 + a * 0.7, 1 - a * 0.5),
+    }[kind]
+    return x * np.asarray(g, dtype=np.float32)
+
+
+def op_haze(x, rng, sev):
+    """Flat veil of light, slightly warm gray — washed-out sunset haze."""
+    h = rng.uniform(0.05, 0.20) * sev
+    veil = np.asarray(
+        [0.92, 0.88 + rng.uniform(-0.04, 0.02), 0.82 + rng.uniform(-0.06, 0.06)],
+        dtype=np.float32)
+    return x * (1 - h) + veil * h
+
+
+def op_bloom(x, rng, sev):
+    """Highlights bleed/glow (bright windows, sky) via screen blend."""
+    thr = rng.uniform(0.55, 0.75)
+    amt = rng.uniform(0.35, 0.9) * sev
+    bright = np.clip((x - thr) / (1 - thr), 0, 1)
+    glow = gaussian(bright, max(3.0, 45.0 * scale_of(x)))
+    return 1 - (1 - x) * (1 - glow * amt)
+
+
+def op_flare(x, rng, sev):
+    """Veiling flare: warm radial gradient from a corner, screen-blended."""
+    h, w = x.shape[:2]
+    cy = rng.choice([0.0, 1.0]) * h + rng.uniform(-0.2, 0.2) * h
+    cx = rng.choice([0.0, 1.0]) * w + rng.uniform(-0.2, 0.2) * w
+    yy, xx = np.mgrid[0:h, 0:w].astype(np.float32)
+    d = np.sqrt((yy - cy) ** 2 + (xx - cx) ** 2) / np.hypot(h, w)
+    fall = np.clip(1 - d / rng.uniform(0.55, 0.95), 0, 1) ** 2
+    amt = rng.uniform(0.15, 0.40) * sev
+    tint = np.asarray([1.0, 0.93, 0.80], dtype=np.float32)
+    flare = fall[..., None] * tint * amt
+    return 1 - (1 - x) * (1 - flare)
+
+
+def op_overexpose(x, rng, sev):
+    """Blown highlights / flat bright light: sky goes paper-white."""
+    gain = 1 + rng.uniform(0.15, 0.45) * sev
+    x = np.clip(x * gain, 0, 1)
+    c = 1.0 - rng.uniform(0.05, 0.2) * sev
+    return (x - 0.5) * c + 0.5
+
+
+def op_underexpose(x, rng, sev):
+    """Moody dark edit: dropped exposure, punchy contrast."""
+    gain = 1 - rng.uniform(0.15, 0.4) * sev
+    x = x * gain
+    c = 1 + rng.uniform(0.1, 0.35) * sev
+    return (x - 0.45) * c + 0.45
+
+
+def op_ghost(x, rng, sev):
+    """Lens ghost: translucent bright blob(s), like night flash shots."""
+    h, w = x.shape[:2]
+    n = rng.choice([1, 1, 2])
+    for _ in range(n):
+        cy, cx = rng.uniform(0.2, 0.8) * h, rng.uniform(0.2, 0.8) * w
+        r = rng.uniform(0.05, 0.16) * max(h, w)
+        yy, xx = np.mgrid[0:h, 0:w].astype(np.float32)
+        d = np.sqrt((yy - cy) ** 2 + (xx - cx) ** 2)
+        blob = np.clip(1 - np.abs(d - r * 0.7) / (r * 0.5), 0, 1) ** 1.5
+        amt = rng.uniform(0.06, 0.18) * sev
+        tint = np.asarray([rng.uniform(0.7, 1.0), 1.0, rng.uniform(0.7, 1.0)],
+                          dtype=np.float32)
+        x = 1 - (1 - x) * (1 - blob[..., None] * tint * amt)
+    return x
+
+
+def op_halo(x, rng, sev, mask):
+    """HDR-edit glow hugging the subject outline (bad dodge/burn halo)."""
+    if mask is None:
+        return op_bloom(x, rng, sev)
+    s = max(3.0, 25.0 * scale_of(x))
+    edge = np.clip(gaussian(mask, s * 2.2) - gaussian(mask, s * 0.5), 0, 1)
+    edge = edge / max(edge.max(), 1e-4)
+    amt = rng.uniform(0.15, 0.4) * sev
+    return 1 - (1 - x) * (1 - edge[..., None] * amt)
+
+
+def op_soft(x, rng, sev):
+    """Global lens softness / slight defocus."""
+    sigma = rng.uniform(0.5, 2.4) * max(0.5, scale_of(x)) * (0.4 + 0.6 * sev)
+    return gaussian(x, sigma)
+
+
+def op_bg_blur(x, rng, sev, mask):
+    """Blur only the background behind the subject (fake bokeh / focus miss)."""
+    if mask is None:
+        return op_soft(x, rng, sev)
+    sigma = rng.uniform(4.0, 13.0) * max(0.5, scale_of(x)) * (0.5 + 0.5 * sev)
+    bg = gaussian(x, sigma)
+    m = gaussian(mask, max(2.0, 6.0 * scale_of(x)))[..., None]
+    return x * m + bg * (1 - m)
+
+
+def op_grain(x, rng, sev):
+    """ISO-style grain: luma noise (optionally coarse) + weaker chroma noise."""
+    h, w = x.shape[:2]
+    std = rng.uniform(0.015, 0.065) * (0.4 + 0.6 * sev)
+    if rng.random() < 0.5:  # coarse grain: generate low-res, upscale
+        f = rng.uniform(1.5, 3.0)
+        n = rng.normal(0, std, (int(h / f), int(w / f), 1)).astype(np.float32)
+        n = cv2.resize(n, (w, h), interpolation=cv2.INTER_LINEAR)[..., None]
+    else:
+        n = rng.normal(0, std, (h, w, 1)).astype(np.float32)
+    x = x + n
+    if rng.random() < 0.6:
+        cn = rng.normal(0, std * 0.5, (h, w, 3)).astype(np.float32)
+        x = x + cn
+    return x
+
+
+def op_oversharpen(x, rng, sev):
+    """Unsharp-mask overdone -> edge halos, the 'overprocessed' look."""
+    radius = rng.uniform(1.2, 3.0) * max(0.5, scale_of(x))
+    amount = rng.uniform(0.7, 2.0) * (0.5 + 0.5 * sev)
+    return x + (x - gaussian(x, radius)) * amount
+
+
+def op_oversaturate(x, rng, sev):
+    hsv = cv2.cvtColor(to_uint8(x), cv2.COLOR_RGB2HSV).astype(np.float32)
+    hsv[..., 1] *= 1 + rng.uniform(0.15, 0.5) * sev
+    hsv[..., 1] = np.clip(hsv[..., 1], 0, 255)
+    return cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2RGB).astype(
+        np.float32) / 255.0
+
+
+def op_crush(x, rng, sev):
+    """Too much contrast: crushed shadows / clipped highlights."""
+    c = 1 + rng.uniform(0.15, 0.5) * sev
+    x = (x - 0.5) * c + 0.5
+    g = rng.uniform(1.02, 1.18)
+    return np.clip(x, 0, 1) ** g
+
+
+def op_downup(x, rng, sev):
+    """Downscale then upscale back: low-res resample mush."""
+    h, w = x.shape[:2]
+    f = 1.0 - rng.uniform(0.2, 0.55) * sev
+    interp = rng.choice([cv2.INTER_LINEAR, cv2.INTER_AREA])
+    small = cv2.resize(x, (max(64, int(w * f)), max(64, int(h * f))),
+                       interpolation=interp)
+    return cv2.resize(small, (w, h), interpolation=cv2.INTER_LINEAR)
+
+
+def op_vignette(x, rng, sev):
+    h, w = x.shape[:2]
+    yy, xx = np.mgrid[0:h, 0:w].astype(np.float32)
+    r2 = ((yy - h / 2) / (h / 2)) ** 2 + ((xx - w / 2) / (w / 2)) ** 2
+    v = rng.uniform(0.10, 0.30) * sev
+    return x * (1 - v * r2[..., None] / 2)
+
+
+def op_jpeg(x, rng, q_lo, q_hi, passes=1):
+    for _ in range(passes):
+        q = int(rng.uniform(q_lo, q_hi))
+        ok, buf = cv2.imencode(".jpg", cv2.cvtColor(to_uint8(x),
+                               cv2.COLOR_RGB2BGR),
+                               [cv2.IMWRITE_JPEG_QUALITY, q])
+        x = cv2.cvtColor(cv2.imdecode(buf, cv2.IMREAD_COLOR),
+                         cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+    return x
+
+
+# ----------------------------------------------------------------------------
+# recipes
+# ----------------------------------------------------------------------------
+
+def recipe_atmospheric(x, rng, sev, mask):
+    """Family A: hazy / faded / bland / glowing. The 'bad light + bad save'."""
+    x = op_fade(x, rng, sev)
+    x = op_desaturate(x, rng, sev)
+    x = op_cast(x, rng, sev)
+    if rng.random() < 0.4:  # blown flat sky (balcony-shot look)
+        x = op_overexpose(x, rng, sev)
+    if rng.random() < 0.65:
+        x = op_haze(x, rng, sev)
+    if rng.random() < 0.6:
+        x = op_bloom(x, rng, sev)
+    if rng.random() < 0.45:
+        x = op_flare(x, rng, sev)
+    if rng.random() < 0.15:
+        x = op_ghost(x, rng, sev)
+    if rng.random() < 0.35 and mask is not None:
+        x = op_bg_blur(x, rng, sev * 0.7, mask)
+    x = op_soft(x, rng, sev * rng.uniform(0.4, 1.0))
+    if rng.random() < 0.8:
+        x = op_grain(x, rng, sev * rng.uniform(0.3, 0.8))
+    if rng.random() < 0.35:
+        x = op_vignette(x, rng, sev)
+    # light-to-medium recompress; heavier when severity is high
+    x = op_jpeg(x, rng, 55 if sev > 0.75 else 68, 88,
+                passes=2 if sev > 0.85 else 1)
+    return x, "atmospheric"
+
+
+def recipe_digital(x, rng, sev, mask):
+    """Family B: digitally mangled / overprocessed."""
+    mode = rng.choice(["grainy_compressed", "overprocessed", "portrait_fail",
+                       "moody_grain"])
+
+    if mode == "grainy_compressed":  # WhatsApp-forward territory
+        if rng.random() < 0.5:
+            x = op_fade(x, rng, sev * 0.7)
+        x = op_desaturate(x, rng, sev * rng.uniform(0.5, 1.0))
+        if rng.random() < 0.5:
+            x = op_cast(x, rng, sev)
+        x = op_downup(x, rng, sev)
+        x = op_grain(x, rng, sev * rng.uniform(0.8, 1.3))
+        x = op_jpeg(x, rng, 35, 62, passes=2 if rng.random() < 0.5 else 1)
+
+    elif mode == "overprocessed":  # halo glow, pushed color, heavy filter
+        if rng.random() < 0.65:
+            x = op_oversaturate(x, rng, sev)
+        else:
+            x = op_desaturate(x, rng, sev * 0.6)
+        if rng.random() < 0.5:  # heavy warm/cool 'filter' cast (yacht look)
+            x = op_cast(x, rng, min(1.0, sev * 1.6))
+        if rng.random() < 0.55:
+            x = op_crush(x, rng, sev)
+        if rng.random() < 0.5 and mask is not None:  # HDR halo (beach look)
+            x = op_halo(x, rng, sev, mask)
+            x = op_soft(x, rng, sev * 0.5)
+        else:
+            x = op_oversharpen(x, rng, sev)
+        x = op_grain(x, rng, sev * rng.uniform(0.6, 1.1))
+        if rng.random() < 0.3:
+            x = op_vignette(x, rng, sev)
+        x = op_jpeg(x, rng, 55, 82)
+
+    elif mode == "moody_grain":  # dark saturated edit + film grain + vignette
+        x = op_underexpose(x, rng, sev)
+        if rng.random() < 0.7:
+            x = op_oversaturate(x, rng, sev * 0.8)
+        if rng.random() < 0.5:
+            x = op_cast(x, rng, sev * 0.7)
+        x = op_grain(x, rng, sev * rng.uniform(0.9, 1.4))
+        x = op_vignette(x, rng, min(1.0, sev * 1.3))
+        if rng.random() < 0.3:
+            x = op_soft(x, rng, sev * 0.4)
+        x = op_jpeg(x, rng, 55, 85)
+
+    else:  # portrait_fail: blurred background + mediocre color
+        x = op_bg_blur(x, rng, sev, mask)
+        x = op_fade(x, rng, sev * 0.8)
+        if rng.random() < 0.7:
+            x = op_cast(x, rng, sev)
+        if rng.random() < 0.5:
+            x = op_soft(x, rng, sev * 0.5)
+        x = op_grain(x, rng, sev * rng.uniform(0.3, 0.8))
+        x = op_jpeg(x, rng, 55, 85)
+
+    return x, f"digital/{mode}"
+
+
+# ----------------------------------------------------------------------------
+# driver
+# ----------------------------------------------------------------------------
+
+def seed_for(name, variant, base_seed):
+    h = hashlib.sha256(f"{base_seed}:{name}:{variant}".encode()).digest()
+    return int.from_bytes(h[:8], "big")
+
+
+def make_contact_sheet(orig, variants, labels, path, height=768):
+    def prep(a):
+        h, w = a.shape[:2]
+        return cv2.resize(a, (int(w * height / h), height))
+    tiles = [prep(orig)] + [prep(v) for v in variants]
+    sheet = np.concatenate(tiles, axis=1)
+    sheet = to_uint8(sheet)
+    for i, lab in enumerate(["original"] + labels):
+        xoff = sum(t.shape[1] for t in tiles[:i]) + 12
+        cv2.putText(sheet, lab, (xoff, 34), cv2.FONT_HERSHEY_SIMPLEX, 0.9,
+                    (0, 0, 0), 4, cv2.LINE_AA)
+        cv2.putText(sheet, lab, (xoff, 34), cv2.FONT_HERSHEY_SIMPLEX, 0.9,
+                    (255, 255, 255), 2, cv2.LINE_AA)
+    Image.fromarray(sheet).save(path, quality=90)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--limit", type=int, default=0, help="0 = all")
+    ap.add_argument("--variants", type=int, default=2)
+    ap.add_argument("--seed", type=int, default=1234)
+    ap.add_argument("--sheets", default="", help="dir for review contact sheets")
+    ap.add_argument("--exclude", default="", help="comma-sep filenames to skip")
+    args = ap.parse_args()
+
+    exclude = {s.strip() for s in args.exclude.split(",") if s.strip()}
+    files = sorted(f for f in os.listdir(args.src)
+                   if f.lower().endswith((".jpg", ".jpeg", ".png"))
+                   and f not in exclude)
+    if args.limit:
+        rng0 = random.Random(args.seed)
+        files = sorted(rng0.sample(files, min(args.limit, len(files))))
+
+    ctrl_dir = os.path.join(args.out, "control")
+    tgt_dir = os.path.join(args.out, "target")
+    os.makedirs(ctrl_dir, exist_ok=True)
+    os.makedirs(tgt_dir, exist_ok=True)
+    if args.sheets:
+        os.makedirs(args.sheets, exist_ok=True)
+
+    families = [recipe_atmospheric, recipe_digital]
+
+    for idx, fname in enumerate(files):
+        stem = os.path.splitext(fname)[0]
+        src_path = os.path.join(args.src, fname)
+        x0 = load_rgb(src_path)
+        # mask computed lazily only if some variant will use it
+        mask = None
+        mask_tried = False
+        variants, labels = [], []
+
+        for v in range(args.variants):
+            rng = np.random.default_rng(seed_for(fname, v, args.seed))
+            pyrng = random.Random(seed_for(fname, v, args.seed) ^ 0xABCD)
+
+            class R:  # tiny facade: uniform/choice/random/normal on one seed
+                uniform = staticmethod(pyrng.uniform)
+                choice = staticmethod(pyrng.choice)
+                random = staticmethod(pyrng.random)
+                normal = staticmethod(rng.normal)
+
+            sev = pyrng.uniform(0.25, 1.0)
+            fam = families[v % len(families)]
+            if not mask_tried:
+                mask = person_mask(src_path, x0.shape)
+                mask_tried = True
+            y, label = fam(x0.copy(), R, sev, mask)
+            label = f"{label} sev={sev:.2f}"
+
+            out_name = f"{stem}_v{v + 1}.jpg"
+            Image.fromarray(to_uint8(y)).save(
+                os.path.join(ctrl_dir, out_name), quality=95)
+            Image.fromarray(to_uint8(x0)).save(
+                os.path.join(tgt_dir, out_name), quality=97)
+            variants.append(y)
+            labels.append(f"v{v + 1} {label}")
+
+        if args.sheets:
+            make_contact_sheet(x0, variants, labels,
+                               os.path.join(args.sheets, f"{stem}_sheet.jpg"))
+        print(f"[{idx + 1}/{len(files)}] {fname}: "
+              + " | ".join(labels), flush=True)
+
+
+if __name__ == "__main__":
+    main()