deploy

.github/workflows/deploy.yml

@@ -0,0 +1,24 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [deploy]
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 1
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git config user.email "ci@github.com"
+          git config user.name "CI"
+          git checkout --orphan hf-clean
+          git add -A
+          git commit -m "deploy"
+          git push https://mvp-lab:$HF_TOKEN@huggingface.co/spaces/mvp-lab/VTON_TEST hf-clean:main -f

.gitignore

@@ -0,0 +1,7 @@
+data/examples/portraits/
+data/examples/garments/
+data/examples/results/
+data/user_uploads/
+__pycache__/
+*.pyc
+.venv/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "fashn-vton-1.5"]
+	path = fashn-vton-1.5
+	url = https://github.com/fashn-AI/fashn-vton-1.5.git

README.md

@@ -0,0 +1,14 @@
+---
+title: MultiSubjectVTON
+emoji: 📊
+colorFrom: red
+colorTo: blue
+sdk: gradio
+sdk_version: 6.7.0
+python_version: '3.12'
+app_file: app.py
+pinned: false
+short_description: Multi-subject VTON model
+fullWidth: false
+logs: true
+---

app.py

@@ -0,0 +1,323 @@
+import spaces
+import cv2
+import numpy as np
+from PIL import Image
+import torch
+from fashn_vton import TryOnPipeline
+from ultralytics import YOLO
+import gradio as gr
+from pathlib import Path
+import subprocess
+import sys
+from scipy.spatial import cKDTree
+from ui import build_demo
+
+
+class MultiPersonVTON:
+    def __init__(self, weights_dir="./weights"):
+        print("Initializing Multi-Person VTON pipeline...")
+        self.pipeline = TryOnPipeline(weights_dir=weights_dir)
+        self.model = YOLO("yolo26n-seg.pt")
+        print("Pipeline initialized")
+
+    def get_mask(self, result, H, W):
+        cls_ids = result.boxes.cls.cpu().numpy().astype(int)
+        person_idxs = cls_ids == 0
+        person_polygons = [poly for poly, keep in zip(result.masks.xy, person_idxs) if keep]
+        masks = []
+        for poly in person_polygons:
+            mask = np.zeros((H, W), dtype=np.uint8)
+            poly_int = np.round(poly).astype(np.int32)
+            cv2.fillPoly(mask, [poly_int], 1)
+            masks.append(mask.astype(bool))
+        return masks
+
+    def extract_people(self, img, masks):
+        img_np = np.array(img) if isinstance(img, Image.Image) else img.copy()
+        people = []
+        for mask in masks:
+            cutout = img_np.copy()
+            cutout[~mask] = 255
+            people.append(Image.fromarray(cutout))
+        return people
+
+    def apply_vton_to_people(self, people, assignments):
+        """Apply VTON per person based on individual assignments.
+
+        assignments: list of {"garment": PIL.Image|None, "category": str} per person.
+        If garment is None, person is kept as-is (skipped).
+        """
+        vton_people = []
+        for i, person in enumerate(people):
+            garment = assignments[i]["garment"]
+            if garment is not None:
+                result = self.pipeline(
+                    person_image=person,
+                    garment_image=garment,
+                    category=assignments[i]["category"]
+                )
+                vton_people.append(result.images[0])
+            else:
+                vton_people.append(person)
+        return vton_people
+
+    def get_vton_masks(self, vton_people):
+        vton_masks = []
+        for people in vton_people:
+            people_arr = np.array(people)
+            gray = cv2.cvtColor(people_arr, cv2.COLOR_RGB2GRAY)
+            _, mask = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY_INV)
+            mask = mask.astype(bool)
+            kernel = np.ones((5, 5), np.uint8)
+            mask_clean = cv2.morphologyEx(mask.astype(np.uint8), cv2.MORPH_OPEN, kernel, iterations=1)
+            mask_clean = cv2.morphologyEx(mask_clean, cv2.MORPH_CLOSE, kernel, iterations=2)
+            mask_u8 = (mask_clean.astype(np.uint8) * 255)
+            mask_blur = cv2.GaussianBlur(mask_u8, (3, 3), 1)
+            vton_masks.append(mask_blur)
+        return vton_masks
+
+    def contour_curvature(self, contour, k=5):
+        pts = contour[:, 0, :].astype(np.float32)
+        N = len(pts)
+        curv = np.zeros(N)
+        for i in range(N):
+            p_prev = pts[(i - k) % N]
+            p = pts[i]
+            p_next = pts[(i + k) % N]
+            v1 = p - p_prev
+            v2 = p_next - p
+            v1 /= (np.linalg.norm(v1) + 1e-6)
+            v2 /= (np.linalg.norm(v2) + 1e-6)
+            angle = np.arccos(np.clip(np.dot(v1, v2), -1, 1))
+            curv[i] = angle
+        return curv
+
+    def frontness_score(self, mask_a, mask_b):
+        inter = mask_a & mask_b
+        if inter.sum() < 50:
+            return 0.0
+        cnts_a, _ = cv2.findContours(mask_a.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+        cnts_b, _ = cv2.findContours(mask_b.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+        if not cnts_a or not cnts_b:
+            return 0.0
+        ca = max(cnts_a, key=len)
+        cb = max(cnts_b, key=len)
+        curv_a = self.contour_curvature(ca)
+        curv_b = self.contour_curvature(cb)
+        inter_pts = np.column_stack(np.where(inter))[:, ::-1]
+        tree_a = cKDTree(ca[:, 0, :])
+        tree_b = cKDTree(cb[:, 0, :])
+        _, idx_a = tree_a.query(inter_pts, k=1)
+        _, idx_b = tree_b.query(inter_pts, k=1)
+        score_a = curv_a[idx_a].mean()
+        score_b = curv_b[idx_b].mean()
+        return score_a - score_b
+
+    def estimate_front_to_back_order(self, masks):
+        n = len(masks)
+        scores = np.zeros(n)
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    continue
+                scores[i] += self.frontness_score(masks[i], masks[j])
+        order = np.argsort(-scores)
+        return order, scores
+
+    def remove_original_people(self, image, person_masks):
+        image_np = np.array(image)
+        combined_mask = np.zeros(image_np.shape[:2], dtype=np.uint8)
+        for mask in person_masks:
+            combined_mask[mask] = 255
+        kernel = np.ones((5, 5), np.uint8)
+        combined_mask = cv2.dilate(combined_mask, kernel, iterations=2)
+        inpainted = cv2.inpaint(image_np, combined_mask, 3, cv2.INPAINT_TELEA)
+        return Image.fromarray(inpainted), combined_mask
+
+    def clean_vton_edges_on_overlap(self, img_pil, mask_uint8, other_masks_uint8,
+                                    erode_iters=1, edge_dilate=2, inner_erode=2):
+        src = np.array(img_pil).copy()
+        others_union = np.zeros_like(mask_uint8, dtype=np.uint8)
+        for m in other_masks_uint8:
+            others_union = np.maximum(others_union, m)
+        overlap = (mask_uint8 > 0) & (others_union > 0)
+        overlap = overlap.astype(np.uint8) * 255
+        if overlap.sum() == 0:
+            return img_pil, mask_uint8
+        kernel = np.ones((3, 3), np.uint8)
+        tight_mask = cv2.erode(mask_uint8, kernel, iterations=erode_iters)
+        edge = cv2.Canny(tight_mask, 50, 150)
+        edge = cv2.dilate(edge, np.ones((3, 3), np.uint8), iterations=edge_dilate)
+        overlap_band = cv2.dilate(overlap, np.ones((5, 5), np.uint8), iterations=1)
+        edge = cv2.bitwise_and(edge, overlap_band)
+        if edge.sum() == 0:
+            return img_pil, tight_mask
+        inner = cv2.erode(tight_mask, np.ones((5, 5), np.uint8), iterations=inner_erode)
+        inner_rgb = cv2.inpaint(src, 255 - inner, 3, cv2.INPAINT_TELEA)
+        src[edge > 0] = inner_rgb[edge > 0]
+        return Image.fromarray(src), tight_mask
+
+    def clean_masks(self, vton_people, vton_masks):
+        cleaned_vton_people = []
+        cleaned_vton_masks = []
+        for i in range(len(vton_people)):
+            other_masks = [m for j, m in enumerate(vton_masks) if j != i]
+            cleaned_img, cleaned_mask = self.clean_vton_edges_on_overlap(
+                vton_people[i], vton_masks[i], other_masks,
+                erode_iters=1, edge_dilate=2, inner_erode=2
+            )
+            cleaned_vton_people.append(cleaned_img)
+            cleaned_vton_masks.append(cleaned_mask)
+        return cleaned_vton_people, cleaned_vton_masks
+
+    def process_group_image(self, group_image, assignments):
+        """Process a group image with per-person garment assignments.
+
+        assignments: list of {"garment": PIL.Image|None, "category": str} per person.
+        """
+        print("Step 1: Loading images...")
+        if isinstance(group_image, np.ndarray):
+            group_image = Image.fromarray(group_image)
+        if isinstance(group_image, Image.Image):
+            group_image.save("people.png")
+
+        img_bgr = cv2.imread("people.png")
+        img = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+        H, W = img.shape[:2]
+
+        print("Step 2: Getting segmentation masks with YOLO...")
+        results = self.model("people.png")
+        result = results[0]
+        masks = self.get_mask(result, H, W)
+        print(f"Found {len(masks)} people")
+
+        print("Step 3: Extracting individual people...")
+        people = self.extract_people(img, masks)
+
+        # Pad assignments to match detected people count
+        while len(assignments) < len(people):
+            assignments.append({"garment": None, "category": "tops"})
+
+        print("Step 4: Applying VTON to people...")
+        vton_people = self.apply_vton_to_people(people, assignments)
+
+        print("Step 5: Getting masks for VTON results...")
+        vton_masks = self.get_vton_masks(vton_people)
+        for i in range(len(vton_masks)):
+            if assignments[i]["garment"] is None:
+                yolo_mask = (masks[i].astype(np.uint8) * 255)
+                yolo_mask = cv2.GaussianBlur(yolo_mask, (3, 3), 1)
+                vton_masks[i] = yolo_mask
+        order, scores = self.estimate_front_to_back_order(vton_masks)
+        cleaned_vton_people, cleaned_vton_masks = self.clean_masks(vton_people, vton_masks)
+
+        print("Step 6: Resizing to match dimensions...")
+        img = cv2.resize(img, vton_people[0].size)
+
+        print("Step 7: Creating clean background by removing original people...")
+        clean_background, person_mask = self.remove_original_people(img, masks)
+        clean_background_np = np.array(clean_background)
+
+        print("Step 8: Recomposing final image...")
+        recomposed = clean_background_np.copy()
+        for i in order:
+            vton_mask = cleaned_vton_masks[i]
+            img_pil = cleaned_vton_people[i]
+            out = recomposed.astype(np.float32)
+            src = np.array(img_pil).astype(np.float32)
+            alpha = (vton_mask.astype(np.float32) / 255.0)[..., None]
+            src = src * alpha
+            out = src + (1 - alpha) * out
+            recomposed = out.astype(np.uint8)
+
+        final_image = Image.fromarray(recomposed)
+        return final_image, {
+            "original": Image.fromarray(img),
+            "clean_background": clean_background,
+            "person_mask": Image.fromarray(person_mask),
+            "num_people": len(people),
+            "individual_people": people,
+            "vton_results": cleaned_vton_people,
+            "masks": masks,
+            "vton_masks": cleaned_vton_masks
+        }
+
+
+WEIGHTS_DIR = Path("./weights")
+
+def ensure_weights():
+    if WEIGHTS_DIR.exists() and any(WEIGHTS_DIR.iterdir()):
+        print("Weights already present, skipping download.")
+        return
+    print("Downloading weights...")
+    subprocess.check_call([
+        sys.executable,
+        "fashn-vton-1.5/scripts/download_weights.py",
+        "--weights-dir",
+        str(WEIGHTS_DIR),
+    ])
+
+ensure_weights()
+
+_pipeline = None
+
+def get_pipeline():
+    global _pipeline
+    if _pipeline is None:
+        _pipeline = MultiPersonVTON()
+    return _pipeline
+
+@spaces.GPU
+def detect_people(portrait_path):
+    if portrait_path is None:
+        raise gr.Error("Please select a portrait first.")
+    portrait = Image.open(portrait_path) if isinstance(portrait_path, str) else portrait_path
+    new_width = 576
+    w, h = portrait.size
+    new_height = int(h * new_width / w)
+    resized = portrait.resize((new_width, new_height), Image.LANCZOS)
+    resized.save("people.png")
+    pipeline = get_pipeline()
+    results = pipeline.model("people.png")
+    result = results[0]
+    img = np.array(resized)
+    H, W = img.shape[:2]
+    masks = pipeline.get_mask(result, H, W)
+    people = pipeline.extract_people(img, masks)
+    return people
+
+@spaces.GPU
+def process_images(selected_portrait, garment_pool, num_detected, *assignment_args):
+    if selected_portrait is None:
+        raise gr.Error("Please select a portrait.")
+    if not garment_pool:
+        raise gr.Error("Please add at least one garment to the pool.")
+    portrait = Image.open(selected_portrait) if isinstance(selected_portrait, str) else selected_portrait
+    pipeline = get_pipeline()
+    new_width = 576
+    w, h = portrait.size
+    new_height = int(h * new_width / w)
+    resized = portrait.resize((new_width, new_height), Image.LANCZOS)
+
+    # Build per-person assignments from dropdown/radio values
+    # assignment_args: dd_0, dd_1, ..., dd_7, cat_0, cat_1, ..., cat_7
+    n = num_detected if num_detected else 0
+    max_p = len(assignment_args) // 2
+    pool_by_label = {g["label"]: g for g in garment_pool}
+    assignments = []
+    for i in range(n):
+        dd_val = assignment_args[i]
+        cat_val = assignment_args[max_p + i]
+        if dd_val == "Skip" or dd_val not in pool_by_label:
+            assignments.append({"garment": None, "category": cat_val or "tops"})
+        else:
+            g = pool_by_label[dd_val]
+            garment_img = Image.open(g["path"]) if isinstance(g["path"], str) else g["path"]
+            assignments.append({"garment": garment_img, "category": cat_val or "tops"})
+
+    result, _ = pipeline.process_group_image(resized, assignments)
+    return result
+
+demo = build_demo(process_images, detect_fn=detect_people, max_people=8)
+from huggingface_hub import constants as hf_constants
+demo.launch(allowed_paths=[hf_constants.HF_HUB_CACHE])

fashn-vton-1.5

@@ -0,0 +1 @@
+Subproject commit 7c0f10af3f91ad4048fe9729c470a13ef905d25a

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+numpY
+Pillow
+Requests
+torch
+ultralytics
+fashn-vton @ git+https://github.com/fashn-AI/fashn-vton-1.5.git

storage.py

@@ -0,0 +1,303 @@
+import os
+import uuid
+import shutil
+from pathlib import Path
+from PIL import Image
+import numpy as np
+
+DATA_REPO = "aj406/vton-data"
+REPO_TYPE = "dataset"
+DATASET_HF_TOKEN = os.environ.get("DATASET_HF_TOKEN")
+LOCAL_DATA = Path("data")
+
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".webp"}
+
+
+def is_remote():
+    return DATASET_HF_TOKEN is not None
+
+
+def _api():
+    from huggingface_hub import HfApi
+    return HfApi()
+
+
+def _ensure_repo():
+    if not is_remote():
+        return
+    _api().create_repo(repo_id=DATA_REPO, repo_type=REPO_TYPE, exist_ok=True, token=DATASET_HF_TOKEN)
+
+
+def save_image(img, local_path):
+    local_path = Path(local_path)
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+    if isinstance(img, np.ndarray):
+        img = Image.fromarray(img)
+    img.save(local_path, "JPEG", quality=85)
+
+
+def upload_image(local_path, remote_path):
+    if not is_remote():
+        return
+    _ensure_repo()
+    _api().upload_file(
+        path_or_fileobj=str(local_path),
+        path_in_repo=remote_path,
+        repo_id=DATA_REPO,
+        repo_type=REPO_TYPE,
+        token=DATASET_HF_TOKEN,
+    )
+
+
+def delete_remote_file(remote_path):
+    if not is_remote():
+        return
+    _api().delete_file(
+        path_in_repo=remote_path,
+        repo_id=DATA_REPO,
+        repo_type=REPO_TYPE,
+        token=DATASET_HF_TOKEN,
+    )
+
+
+def download_dir(remote_prefix):
+    if not is_remote():
+        return
+    from huggingface_hub import snapshot_download
+    snapshot_download(
+        repo_id=DATA_REPO,
+        repo_type=REPO_TYPE,
+        allow_patterns=f"{remote_prefix}/**",
+        local_dir=str(LOCAL_DATA),
+        token=DATASET_HF_TOKEN,
+    )
+
+
+def generate_id():
+    return uuid.uuid4().hex[:8]
+
+
+def make_filename(item_id, item_type):
+    return f"{item_id}_{item_type}.jpg"
+
+
+def parse_filename(filename):
+    stem = Path(filename).stem
+    parts = stem.rsplit("_", 1)
+    if len(parts) != 2:
+        return None
+    return {"id": parts[0], "type": parts[1]}
+
+
+def make_result_filename(portrait_id, garment_id):
+    return f"{portrait_id}_{garment_id}_result.jpg"
+
+
+def parse_result_filename(filename):
+    stem = Path(filename).stem
+    parts = stem.rsplit("_", 2)
+    if len(parts) != 3 or parts[2] != "result":
+        return None
+    if "-" in parts[1]:
+        return None
+    return {"portrait_id": parts[0], "garment_id": parts[1]}
+
+
+def make_multi_result_filename(portrait_id, garment_ids):
+    """Build result filename encoding per-person garment assignments.
+
+    garment_ids: list of garment_id (str) or None per person.
+    Example: portrait_id=abc123, garment_ids=["ef12ab34", None, "gh56cd78"]
+    → "abc123_ef12ab34-x-gh56cd78_result.jpg"
+    """
+    slots = [gid if gid else "x" for gid in garment_ids]
+    code = "-".join(slots)
+    return f"{portrait_id}_{code}_result.jpg"
+
+
+def parse_multi_result_filename(filename):
+    stem = Path(filename).stem
+    if not stem.endswith("_result"):
+        return None
+    stem = stem[:-len("_result")]
+    parts = stem.split("_", 1)
+    if len(parts) != 2:
+        return None
+    portrait_id = parts[0]
+    code = parts[1]
+    slots = code.split("-")
+    garment_ids = [None if slot == "x" else slot for slot in slots]
+    return {"portrait_id": portrait_id, "garment_ids": garment_ids}
+
+
+def list_local_images(directory):
+    d = Path(directory)
+    if not d.exists():
+        return []
+    return sorted([str(p) for p in d.iterdir() if p.suffix.lower() in IMG_EXTS])
+
+
+def file_url(remote_path):
+    """Return a direct HF URL for a file in the dataset repo (public repo)."""
+    return f"https://huggingface.co/datasets/{DATA_REPO}/resolve/main/{remote_path}"
+
+
+def list_gallery_urls(prefix, subdir):
+    """List files in dataset repo and return direct URLs for gallery display."""
+    if not is_remote():
+        return list_local_images(LOCAL_DATA / prefix / subdir)
+    try:
+        items = _api().list_repo_tree(
+            DATA_REPO, repo_type=REPO_TYPE, path_in_repo=f"{prefix}/{subdir}"
+        )
+        urls = []
+        for item in items:
+            if hasattr(item, "rfilename"):
+                name = item.rfilename
+            elif hasattr(item, "path"):
+                name = item.path
+            else:
+                continue
+            if Path(name).suffix.lower() in IMG_EXTS:
+                urls.append(file_url(name))
+        return sorted(urls)
+    except Exception:
+        return list_local_images(LOCAL_DATA / prefix / subdir)
+
+
+HF_URL_PREFIX = f"https://huggingface.co/datasets/{DATA_REPO}/resolve/main/"
+
+
+def is_dataset_url(url):
+    """Check if a URL points to our HF dataset repo."""
+    return isinstance(url, str) and url.startswith(HF_URL_PREFIX)
+
+
+def download_to_local(path_or_url):
+    """Download a URL to local path. HF dataset URLs use hf_hub, other URLs use requests."""
+    if not isinstance(path_or_url, str):
+        return path_or_url
+    if is_dataset_url(path_or_url):
+        remote_path = path_or_url[len(HF_URL_PREFIX):]
+        from huggingface_hub import hf_hub_download
+        local = hf_hub_download(
+            repo_id=DATA_REPO,
+            repo_type=REPO_TYPE,
+            filename=remote_path,
+            token=DATASET_HF_TOKEN,
+        )
+        return local
+    if path_or_url.startswith(("http://", "https://")):
+        import requests
+        from io import BytesIO
+        resp = requests.get(path_or_url, timeout=30)
+        resp.raise_for_status()
+        img = Image.open(BytesIO(resp.content))
+        tmp_path = LOCAL_DATA / "tmp" / f"{generate_id()}.jpg"
+        tmp_path.parent.mkdir(parents=True, exist_ok=True)
+        save_image(img, tmp_path)
+        return str(tmp_path)
+    return path_or_url
+
+
+def load_image_sets(prefix):
+    """Scan {prefix}/portraits/ dir, parse filenames, return list of dicts with matched files."""
+    local_prefix = LOCAL_DATA / prefix
+    if is_remote():
+        download_dir(prefix)
+    portraits_dir = local_prefix / "portraits"
+    if not portraits_dir.exists():
+        return []
+    sets = {}
+    for p in portraits_dir.iterdir():
+        if p.suffix.lower() not in IMG_EXTS:
+            continue
+        parsed = parse_filename(p.name)
+        if not parsed:
+            continue
+        item_id = parsed["id"]
+        sets[item_id] = {
+            "id": item_id,
+            "portrait": str(p),
+        }
+    garments_dir = local_prefix / "garments"
+    results_dir = local_prefix / "results"
+    for item_id, entry in sets.items():
+        garment = garments_dir / f"{item_id}_garment.jpg"
+        result = results_dir / f"{item_id}_result.jpg"
+        entry["garment"] = str(garment) if garment.exists() else None
+        entry["result"] = str(result) if result.exists() else None
+    return [v for v in sets.values() if v["garment"] is not None]
+
+
+def save_image_set(prefix, img_portrait, img_garment, img_result=None):
+    """Save a set of images (portrait + garment + optional result) with consistent naming."""
+    item_id = generate_id()
+    local_prefix = LOCAL_DATA / prefix
+
+    portrait_name = make_filename(item_id, "portrait")
+    garment_name = make_filename(item_id, "garment")
+
+    portrait_path = local_prefix / "portraits" / portrait_name
+    garment_path = local_prefix / "garments" / garment_name
+
+    save_image(img_portrait, portrait_path)
+    save_image(img_garment, garment_path)
+    upload_image(portrait_path, f"{prefix}/portraits/{portrait_name}")
+    upload_image(garment_path, f"{prefix}/garments/{garment_name}")
+
+    result_path = None
+    if img_result is not None:
+        result_name = make_result_filename(item_id, item_id)
+        result_path = local_prefix / "results" / result_name
+        save_image(img_result, result_path)
+        upload_image(result_path, f"{prefix}/results/{result_name}")
+
+    return item_id, str(portrait_path), str(garment_path), str(result_path) if result_path else None
+
+
+def save_result(prefix, portrait_id, garment_id, img_result):
+    """Save a result image encoding both portrait and garment IDs."""
+    local_prefix = LOCAL_DATA / prefix
+    result_name = make_result_filename(portrait_id, garment_id)
+    result_path = local_prefix / "results" / result_name
+    save_image(img_result, result_path)
+    upload_image(result_path, f"{prefix}/results/{result_name}")
+    return str(result_path)
+
+
+def save_multi_result(prefix, portrait_id, assignments, img_result):
+    """Save a multi-garment result image with assignment-encoded filename."""
+    local_prefix = LOCAL_DATA / prefix
+    result_name = make_multi_result_filename(portrait_id, assignments)
+    result_path = local_prefix / "results" / result_name
+    save_image(img_result, result_path)
+    upload_image(result_path, f"{prefix}/results/{result_name}")
+    return str(result_path)
+
+
+def delete_image_set(prefix, item_id):
+    """Delete all files for an image set (scans for ID prefix to catch multi-garment files)."""
+    local_prefix = LOCAL_DATA / prefix
+    for subdir in ("portraits", "garments", "results"):
+        d = local_prefix / subdir
+        if not d.exists():
+            continue
+        for f in d.iterdir():
+            if f.stem.startswith(item_id):
+                f.unlink()
+                if is_remote():
+                    try:
+                        delete_remote_file(f"{prefix}/{subdir}/{f.name}")
+                    except Exception:
+                        pass
+
+
+def promote_to_example(result_path):
+    """Copy a result file to examples, preserving its filename for resolution."""
+    src = Path(result_path)
+    dest = LOCAL_DATA / "examples" / "results" / src.name
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(str(src), str(dest))
+    upload_image(dest, f"examples/results/{src.name}")
+    return src.stem

ui.py

@@ -0,0 +1,493 @@
+import gradio as gr
+from PIL import Image
+from pathlib import Path
+from storage import (
+    save_multi_result,
+    delete_image_set,
+    promote_to_example,
+    list_gallery_urls,
+    download_to_local,
+    is_dataset_url,
+    save_image,
+    upload_image,
+    make_filename,
+    generate_id,
+    parse_filename,
+    parse_result_filename,
+    parse_multi_result_filename,
+    file_url,
+    LOCAL_DATA,
+)
+
+EXAMPLES_PREFIX = "examples"
+UPLOADS_PREFIX = "user_uploads"
+
+for subdir in ["portraits", "garments", "results"]:
+    (LOCAL_DATA / EXAMPLES_PREFIX / subdir).mkdir(parents=True, exist_ok=True)
+    (LOCAL_DATA / UPLOADS_PREFIX / subdir).mkdir(parents=True, exist_ok=True)
+
+
+def _gallery_images(prefix, subdir):
+    return list_gallery_urls(prefix, subdir)
+
+
+MAX_PEOPLE = 8
+
+
+def build_demo(process_fn, detect_fn=None, max_people=MAX_PEOPLE):
+
+    def process_and_save(portrait_path, garment_pool, num_detected, *assignment_args):
+        if portrait_path is None:
+            raise gr.Error("Please select a portrait.")
+        if not garment_pool:
+            raise gr.Error("Please add at least one garment to the pool.")
+        result = process_fn(portrait_path, garment_pool, num_detected, *assignment_args)
+        if result and portrait_path:
+            p_parsed = parse_filename(Path(portrait_path).name)
+            if p_parsed:
+                # Upload portrait if local
+                local = Path(portrait_path)
+                if local.exists() and str(local).startswith(str(LOCAL_DATA)):
+                    upload_image(local, str(local.relative_to(LOCAL_DATA)))
+                # Upload all garments in pool
+                for g in garment_pool:
+                    garment_local = Path(g["path"])
+                    if garment_local.exists() and str(garment_local).startswith(str(LOCAL_DATA)):
+                        upload_image(garment_local, str(garment_local.relative_to(LOCAL_DATA)))
+                # Build garment ID list for filename
+                n = num_detected if num_detected else 0
+                max_p = len(assignment_args) // 2
+                pool_by_label = {g["label"]: g for g in garment_pool}
+                garment_ids = []
+                for i in range(n):
+                    dd_val = assignment_args[i]
+                    if dd_val == "Skip" or dd_val not in pool_by_label:
+                        garment_ids.append(None)
+                    else:
+                        g = pool_by_label[dd_val]
+                        g_parsed = parse_filename(Path(g["path"]).name)
+                        garment_ids.append(g_parsed["id"] if g_parsed else generate_id())
+                save_multi_result(UPLOADS_PREFIX, p_parsed["id"], garment_ids, result)
+        return result
+
+    with gr.Blocks(title="Multi-Person Virtual Try-On") as demo:
+        with gr.Tabs():
+            # ---- Main VTON Tab ----
+            with gr.Tab("Virtual Try-On"):
+                gr.Markdown("# Multi-Person Virtual Try-On")
+                gr.Markdown("Select a portrait, add garments to the pool, detect people, and assign garments.")
+
+                selected_portrait = gr.State(value=None)
+                garment_pool = gr.State(value=[])
+                num_detected = gr.State(value=0)
+                garment_counter = gr.State(value=0)
+
+                gr.Markdown("**Step 1:** Select or upload a portrait, and select or upload garments to the pool.")
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Portrait")
+                        portrait_gallery = gr.Gallery(
+                            value=_gallery_images(UPLOADS_PREFIX, "portraits"),
+                            label="Uploaded Portraits",
+                            columns=4,
+                            height=200,
+                            allow_preview=False,
+                        )
+                        with gr.Accordion("Upload new portrait", open=False):
+                            portrait_upload = gr.Image(type="pil", label="Upload Portrait", sources=["upload", "webcam"])
+                            with gr.Row():
+                                portrait_url_input = gr.Textbox(label="Or paste image URL", scale=4)
+                                portrait_url_btn = gr.Button("Load", size="sm", scale=1)
+                        preview_portrait = gr.Image(label="Selected Portrait", interactive=False, height=250)
+
+                    # Garment pool section
+                    with gr.Column():
+                        gr.Markdown("### Garment Pool")
+                        garment_gallery = gr.Gallery(
+                            value=_gallery_images(UPLOADS_PREFIX, "garments"),
+                            label="Available Garments (click to add to pool)",
+                            columns=4,
+                            height=200,
+                            allow_preview=False,
+                        )
+                        with gr.Accordion("Upload new garment", open=False):
+                            garment_upload = gr.Image(type="pil", label="Upload Garment", sources=["upload", "webcam"])
+                            with gr.Row():
+                                garment_url_input = gr.Textbox(label="Or paste image URL", scale=4)
+                                garment_url_btn = gr.Button("Load", size="sm", scale=1)
+                        garment_pool_gallery = gr.Gallery(
+                            label="Current Pool",
+                            columns=6,
+                            height=250,
+                            allow_preview=False,
+                        )
+                        clear_pool_btn = gr.Button("Clear Pool", size="sm", variant="stop")
+
+                gr.Markdown("**Step 2:** Detect people in the portrait. This lets you choose which garment goes on each person.")
+                detect_btn = gr.Button("Detect People", variant="secondary")
+                detect_status = gr.Textbox(interactive=False, show_label=False, value="")
+                people_gallery = gr.Gallery(
+                    label="Detected People",
+                    columns=6,
+                    height=300,
+                    allow_preview=False,
+                )
+
+                gr.Markdown("**Step 3:** Assign garments to each person, then click Try On.")
+                @gr.render(inputs=[num_detected, garment_pool])
+                def render_assignments(n_detected, pool):
+                    n = n_detected or 0
+                    choices = ["Skip"] + [g["label"] for g in (pool or [])]
+                    default_garment = choices[1] if len(choices) > 1 else "Skip"
+
+                    if n > 0:
+                        gr.Markdown(f"### Assign Garments to {n} {'Person' if n == 1 else 'People'}")
+
+                    dds = []
+                    cats = []
+                    for i in range(n):
+                        with gr.Row():
+                            dd = gr.Dropdown(
+                                choices=choices,
+                                value=default_garment,
+                                label=f"Person {i + 1} — Garment",
+                                scale=3,
+                                interactive=True,
+                            )
+                            cat = gr.Radio(
+                                choices=["tops", "bottoms", "one-pieces"],
+                                value="tops",
+                                label="Category",
+                                scale=2,
+                                interactive=True,
+                            )
+                            dds.append(dd)
+                            cats.append(cat)
+
+                    submit_btn = gr.Button("Try On", variant="primary")
+                    result_image = gr.Image(type="pil", label="Result", interactive=False)
+
+                    submit_btn.click(
+                        process_and_save,
+                        inputs=[selected_portrait, garment_pool, num_detected] + dds + cats,
+                        outputs=result_image,
+                    )
+
+                # Examples section
+                gr.Markdown("---")
+                gr.Markdown("### Examples")
+                example_sets = gr.State(value=[])
+                refresh_examples_btn = gr.Button("Refresh Examples", size="sm")
+
+                @gr.render(inputs=[example_sets])
+                def render_examples(sets):
+                    for i, ex in enumerate(sets or []):
+                        with gr.Row():
+                            gr.Image(value=ex["portrait"], label="Portrait", height=200, interactive=False, scale=1)
+                            for j, g in enumerate(ex["garments"]):
+                                gr.Image(value=g, label=f"Garment {j+1}", height=200, interactive=False, scale=1)
+                            gr.Image(value=ex["result"], label="Result", height=200, interactive=False, scale=1)
+                            use_btn = gr.Button("Use", size="sm", scale=0, min_width=60)
+                            use_btn.click(
+                                lambda p=ex["portrait"], gs=ex["garments"]: _load_example(p, gs),
+                                outputs=[selected_portrait, preview_portrait, garment_pool, garment_counter, garment_pool_gallery],
+                            )
+
+                # -- Event handlers --
+
+                def on_portrait_gallery_select(evt: gr.SelectData):
+                    path = evt.value["image"]["path"]
+                    local_path = download_to_local(path)
+                    return local_path, local_path
+
+                def on_garment_gallery_select(evt: gr.SelectData, pool, counter):
+                    """Add selected garment to pool."""
+                    path = evt.value["image"]["path"]
+                    local_path = download_to_local(path)
+                    new_counter = counter + 1
+                    label = f"Garment {new_counter}"
+                    new_pool = pool + [{"path": local_path, "label": label}]
+                    pool_images = [g["path"] for g in new_pool]
+                    return new_pool, new_counter, pool_images
+
+                def _load_example(portrait_path, garment_paths):
+                    pool = [{"path": g, "label": f"Garment {i+1}"} for i, g in enumerate(garment_paths)]
+                    pool_images = [g["path"] for g in pool]
+                    return portrait_path, portrait_path, pool, len(pool), pool_images
+
+                def clear_pool():
+                    return [], 0, [], _gallery_images(UPLOADS_PREFIX, "garments")
+
+                def reset_detection():
+                    return "", [], 0
+
+                detection_reset_outputs = [detect_status, people_gallery, num_detected]
+
+                portrait_gallery.select(
+                    on_portrait_gallery_select, outputs=[selected_portrait, preview_portrait]
+                ).then(reset_detection, outputs=detection_reset_outputs)
+
+                garment_gallery.select(
+                    on_garment_gallery_select,
+                    inputs=[garment_pool, garment_counter],
+                    outputs=[garment_pool, garment_counter, garment_pool_gallery],
+                )
+
+                clear_pool_btn.click(
+                    clear_pool,
+                    outputs=[garment_pool, garment_counter, garment_pool_gallery, garment_gallery],
+                )
+
+                def on_portrait_upload(img, current_pool):
+                    if img is None:
+                        return _gallery_images(UPLOADS_PREFIX, "portraits"), None, None, None
+                    item_id = generate_id()
+                    fname = make_filename(item_id, "portrait")
+                    local_path = LOCAL_DATA / UPLOADS_PREFIX / "portraits" / fname
+                    save_image(img, local_path)
+                    path = str(local_path)
+                    return _gallery_images(UPLOADS_PREFIX, "portraits"), path, path, None
+
+                def on_garment_upload(img, pool, counter):
+                    if img is None:
+                        return _gallery_images(UPLOADS_PREFIX, "garments"), pool, counter, [g["path"] for g in pool], None
+                    item_id = generate_id()
+                    fname = make_filename(item_id, "garment")
+                    local_path = LOCAL_DATA / UPLOADS_PREFIX / "garments" / fname
+                    save_image(img, local_path)
+                    path = str(local_path)
+                    new_counter = counter + 1
+                    label = f"Garment {new_counter}"
+                    new_pool = pool + [{"path": path, "label": label}]
+                    pool_images = [g["path"] for g in new_pool]
+                    return _gallery_images(UPLOADS_PREFIX, "garments"), new_pool, new_counter, pool_images, None
+
+                def on_portrait_url(url, pool):
+                    if not url or not url.strip():
+                        return _gallery_images(UPLOADS_PREFIX, "portraits"), None, None, ""
+                    local_path = download_to_local(url.strip())
+                    if not is_dataset_url(url.strip()):
+                        from PIL import Image as PILImage
+                        item_id = generate_id()
+                        fname = make_filename(item_id, "portrait")
+                        dest = LOCAL_DATA / UPLOADS_PREFIX / "portraits" / fname
+                        save_image(PILImage.open(local_path), dest)
+                        local_path = str(dest)
+                    return _gallery_images(UPLOADS_PREFIX, "portraits"), local_path, local_path, ""
+
+                def on_garment_url(url, pool, counter):
+                    if not url or not url.strip():
+                        return _gallery_images(UPLOADS_PREFIX, "garments"), pool, counter, [g["path"] for g in pool], ""
+                    local_path = download_to_local(url.strip())
+                    if not is_dataset_url(url.strip()):
+                        from PIL import Image as PILImage
+                        item_id = generate_id()
+                        fname = make_filename(item_id, "garment")
+                        dest = LOCAL_DATA / UPLOADS_PREFIX / "garments" / fname
+                        save_image(PILImage.open(local_path), dest)
+                        local_path = str(dest)
+                    new_counter = counter + 1
+                    label = f"Garment {new_counter}"
+                    new_pool = pool + [{"path": local_path, "label": label}]
+                    pool_images = [g["path"] for g in new_pool]
+                    return _gallery_images(UPLOADS_PREFIX, "garments"), new_pool, new_counter, pool_images, ""
+
+                portrait_upload.change(
+                    on_portrait_upload,
+                    inputs=[portrait_upload, garment_pool],
+                    outputs=[portrait_gallery, selected_portrait, preview_portrait, portrait_upload],
+                ).then(reset_detection, outputs=detection_reset_outputs)
+
+                garment_upload.change(
+                    on_garment_upload,
+                    inputs=[garment_upload, garment_pool, garment_counter],
+                    outputs=[garment_gallery, garment_pool, garment_counter, garment_pool_gallery, garment_upload],
+                )
+
+                portrait_url_btn.click(
+                    on_portrait_url,
+                    inputs=[portrait_url_input, garment_pool],
+                    outputs=[portrait_gallery, selected_portrait, preview_portrait, portrait_url_input],
+                ).then(reset_detection, outputs=detection_reset_outputs)
+
+                garment_url_btn.click(
+                    on_garment_url,
+                    inputs=[garment_url_input, garment_pool, garment_counter],
+                    outputs=[garment_gallery, garment_pool, garment_counter, garment_pool_gallery, garment_url_input],
+                )
+
+                def on_detect(portrait_path, pool):
+                    if detect_fn is None or portrait_path is None:
+                        raise gr.Error("Please select a portrait first.")
+                    people = detect_fn(portrait_path)
+                    n = len(people)
+                    return f"Found {n} {'person' if n == 1 else 'people'}", people, n
+
+                detect_btn.click(
+                    lambda: "Detecting people...",
+                    outputs=[detect_status],
+                ).then(
+                    on_detect,
+                    inputs=[selected_portrait, garment_pool],
+                    outputs=[detect_status, people_gallery, num_detected],
+                )
+
+                def refresh_examples():
+                    result_urls = _gallery_images(EXAMPLES_PREFIX, "results")
+                    sets = []
+                    for r in result_urls:
+                        portrait, garments, result = _resolve_result_images(UPLOADS_PREFIX, r)
+                        if portrait and garments:
+                            sets.append({"portrait": portrait, "garments": garments, "result": result})
+                    return sets
+
+                refresh_examples_btn.click(
+                    refresh_examples,
+                    outputs=[example_sets],
+                )
+                demo.load(
+                    refresh_examples,
+                    outputs=[example_sets],
+                )
+
+            # ---- Admin Tab ----
+            with gr.Tab("Admin - Manage Examples"):
+                admin_status = gr.Textbox(label="Status", interactive=False)
+
+                gr.Markdown("### Current Examples")
+                admin_examples_table = gr.Dataframe(
+                    headers=["ID", "Result Filename"],
+                    label="Examples",
+                    interactive=False,
+                )
+
+                with gr.Row():
+                    delete_id = gr.Textbox(label="Example ID to delete", scale=3)
+                    delete_btn = gr.Button("Delete", variant="stop", scale=1)
+
+                def get_examples_table():
+                    results = list_gallery_urls(EXAMPLES_PREFIX, "results")
+                    rows = []
+                    for r in results:
+                        fname = Path(r).name
+                        parsed = parse_result_filename(fname) or parse_multi_result_filename(fname)
+                        rid = parsed["portrait_id"] if parsed else Path(fname).stem
+                        rows.append([rid, fname])
+                    return rows
+
+                def on_admin_delete(ex_id):
+                    if not ex_id:
+                        return "Please provide an ID.", get_examples_table()
+                    delete_image_set(EXAMPLES_PREFIX, ex_id.strip())
+                    return "Deleted.", get_examples_table()
+
+                delete_btn.click(
+                    on_admin_delete,
+                    inputs=[delete_id],
+                    outputs=[admin_status, admin_examples_table],
+                )
+
+                # ---- Promote from Uploads ----
+                gr.Markdown("---")
+                gr.Markdown("## Promote from Uploads")
+                gr.Markdown("Select a result to promote. The matching portrait and garment are found automatically.")
+
+                promote_portrait = gr.State(value=None)
+                promote_garments = gr.State(value=[])
+                promote_result = gr.State(value=None)
+
+                promo_result_gallery = gr.Gallery(
+                    value=_gallery_images(UPLOADS_PREFIX, "results"),
+                    label="Results",
+                    columns=4,
+                    height=200,
+                    allow_preview=False,
+                )
+
+                with gr.Row():
+                    promo_preview_portrait = gr.Image(label="Portrait", interactive=False, height=150)
+                    promo_preview_garments = gr.Gallery(label="Garments", columns=4, height=150, allow_preview=False)
+                    promo_preview_result = gr.Image(label="Result", interactive=False, height=150)
+
+                promote_btn = gr.Button("Promote to Example", variant="primary")
+                promote_status = gr.Textbox(label="Status", interactive=False)
+
+                def _resolve_result_images(prefix, path):
+                    """Parse a result filename and resolve portrait + all garments."""
+                    result_local = download_to_local(path)
+                    fname = Path(result_local).name
+                    # Try single-garment format
+                    parsed = parse_result_filename(fname)
+                    if not parsed:
+                        parsed = parse_result_filename(Path(path).name)
+                    if parsed:
+                        try:
+                            p_url = file_url(f"{prefix}/portraits/{make_filename(parsed['portrait_id'], 'portrait')}")
+                            g_url = file_url(f"{prefix}/garments/{make_filename(parsed['garment_id'], 'garment')}")
+                            return download_to_local(p_url), [download_to_local(g_url)], result_local
+                        except Exception as e:
+                            gr.Warning(f"Single-garment resolve failed for {fname}: {e}")
+                    # Try multi-garment format
+                    multi = parse_multi_result_filename(fname)
+                    if not multi:
+                        multi = parse_multi_result_filename(Path(path).name)
+                    if multi:
+                        gids = [gid for gid in multi["garment_ids"] if gid is not None]
+                        if gids:
+                            try:
+                                p_url = file_url(f"{prefix}/portraits/{make_filename(multi['portrait_id'], 'portrait')}")
+                                portrait_local = download_to_local(p_url)
+                                garment_locals = []
+                                for gid in gids:
+                                    g_url = file_url(f"{prefix}/garments/{make_filename(gid, 'garment')}")
+                                    garment_locals.append(download_to_local(g_url))
+                                return portrait_local, garment_locals, result_local
+                            except Exception as e:
+                                gr.Warning(f"Multi-garment resolve failed for {fname} (portrait={multi['portrait_id']}, garments={gids}): {e}")
+                    else:
+                        gr.Warning(f"Could not parse result filename: {fname}")
+                    return None, [], result_local
+
+                def on_result_select(evt: gr.SelectData):
+                    path = evt.value["image"]["path"]
+                    portrait_local, garment_locals, result_local = _resolve_result_images(UPLOADS_PREFIX, path)
+                    if not portrait_local or not garment_locals:
+                        gr.Warning(f"Could not find matching portrait/garment for: {Path(path).name}")
+                    return portrait_local, garment_locals, result_local, portrait_local, garment_locals, result_local
+
+                promo_result_gallery.select(
+                    on_result_select,
+                    outputs=[promote_portrait, promote_garments, promote_result,
+                             promo_preview_portrait, promo_preview_garments, promo_preview_result],
+                )
+
+                def on_promote(portrait_path, garment_paths, result_path):
+                    if not result_path:
+                        return "No result to promote.", get_examples_table()
+                    name = promote_to_example(result_path)
+                    return f"Promoted: {name}", get_examples_table()
+
+                promote_btn.click(
+                    on_promote,
+                    inputs=[promote_portrait, promote_garments, promote_result],
+                    outputs=[promote_status, admin_examples_table],
+                )
+
+                refresh_promo_btn = gr.Button("Refresh Results", size="sm")
+                refresh_promo_btn.click(
+                    lambda: _gallery_images(UPLOADS_PREFIX, "results"),
+                    outputs=[promo_result_gallery],
+                )
+
+                demo.load(get_examples_table, outputs=[admin_examples_table])
+
+    return demo
+
+
+if __name__ == "__main__":
+    def dummy_process(portrait, pool, num_detected, *assignment_args):
+        return Image.new("RGB", (512, 512), (200, 200, 200))
+    def dummy_detect(portrait_path):
+        return [Image.new("RGB", (100, 200), (255, 0, 0)), Image.new("RGB", (100, 200), (0, 255, 0))]
+    demo = build_demo(dummy_process, detect_fn=dummy_detect)
+    demo.launch()