update

.history/README_20260615121735.md

@@ -0,0 +1,54 @@
+---
+title: ChitraTech Virtual Try-On
+emoji: 👕
+colorFrom: pink
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.5.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# ChitraTech Virtual Try-On
+
+This repository is a Hugging Face Space for an on-demand virtual try-on experience powered by **CatVTON**.
+
+## Planned flow
+
+1. A shopper clicks **Try On** on your ecommerce product page.
+2. Your frontend sends the shopper photo and the selected clothing image to this Hugging Face Space.
+3. The Space runs CatVTON inference only for that request.
+4. The generated try-on image is returned to the frontend for preview.
+
+## Current status
+
+The current `app.py` is prepared as a **CatVTON-ready Gradio shell**:
+- accepts a person image and a garment image,
+- keeps preprocessing inside the Space,
+- uses lazy pipeline loading for on-demand inference,
+- includes clear placeholders where CatVTON model loading and inference should be added.
+
+## Next steps to finish the Space
+
+- clone or copy the CatVTON inference code into this repository,
+- add a `requirements.txt` with CatVTON and runtime dependencies,
+- place model weights in a folder such as `checkpoints/CatVTON` or download them during startup,
+- replace the placeholder pipeline in `app.py` with actual CatVTON inference logic,
+- push updates to Git so Hugging Face rebuilds the Space automatically.
+
+## Frontend integration
+
+Your ecommerce frontend can call the Hugging Face Space directly when needed, making this a free, on-demand approach without keeping a GPU server running continuously.
+
+## Recommended repository additions
+
+You will likely want to add:
+- `requirements.txt`
+- `checkpoints/` or startup download logic
+- optional `examples/` assets for demo inputs
+- optional `utils/` or `catvton/` helper modules
+
+## Note
+
+If you want, the next step is to wire real CatVTON inference into `app.py` and add the missing dependency files for Hugging Face Spaces deployment.

.history/README_20260615121752.md

@@ -0,0 +1,54 @@
+---
+title: ChitraTech Virtual Try-On
+emoji: 👕
+colorFrom: pink
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.5.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# ChitraTech Virtual Try-On
+
+This repository is a Hugging Face Space for an on-demand virtual try-on experience powered by **CatVTON**.
+
+## Planned flow
+
+1. A shopper clicks **Try On** on your ecommerce product page.
+2. Your frontend sends the shopper photo and the selected clothing image to this Hugging Face Space.
+3. The Space runs CatVTON inference only for that request.
+4. The generated try-on image is returned to the frontend for preview.
+
+## Current status
+
+The current `app.py` is prepared as a **CatVTON-ready Gradio shell**:
+- accepts a person image and a garment image,
+- keeps preprocessing inside the Space,
+- uses lazy pipeline loading for on-demand inference,
+- includes clear placeholders where CatVTON model loading and inference should be added.
+
+## Next steps to finish the Space
+
+- clone or copy the CatVTON inference code into this repository,
+- add a `requirements.txt` with CatVTON and runtime dependencies,
+- place model weights in a folder such as `checkpoints/CatVTON` or download them during startup,
+- replace the placeholder pipeline in `app.py` with actual CatVTON inference logic,
+- push updates to Git so Hugging Face rebuilds the Space automatically.
+
+## Frontend integration
+
+Your ecommerce frontend can call the Hugging Face Space directly when needed, making this a free, on-demand approach without keeping a GPU server running continuously.
+
+## Recommended repository additions
+
+You will likely want to add:
+- `requirements.txt`
+- `checkpoints/` or startup download logic
+- optional `examples/` assets for demo inputs
+- optional `utils/` or `catvton/` helper modules
+
+## Note
+
+If you want, the next step is to wire real CatVTON inference into `app.py` and add the missing dependency files for Hugging Face Spaces deployment.

.history/README_20260615121943.md

@@ -0,0 +1,74 @@
+---
+title: ChitraTech Virtual Try-On
+emoji: 👕
+colorFrom: pink
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.5.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# ChitraTech Virtual Try-On
+
+This repository is a Hugging Face Space for an on-demand virtual try-on experience powered by **CatVTON**.
+
+## Planned flow
+
+1. A shopper clicks **Try On** on your ecommerce product page.
+2. Your frontend sends the shopper photo and the selected clothing image to this Hugging Face Space.
+3. The Space runs CatVTON inference only for that request.
+4. The generated try-on image is returned to the frontend for preview.
+
+## Current status
+
+The current Space now includes:
+- a Gradio interface for person and garment uploads,
+- lazy pipeline initialization for on-demand inference,
+- automatic detection of CatVTON code under `CatVTON/`,
+- automatic detection of model weights under `checkpoints/CatVTON/`,
+- a safe demo fallback when CatVTON is not fully installed yet.
+
+## Repository structure
+
+Recommended layout:
+- `app.py`
+- `requirements.txt`
+- `CatVTON/` for the cloned CatVTON repository
+- `checkpoints/CatVTON/` for model weights
+- optional `examples/` for demo assets
+
+## Setup steps
+
+### 1. Add CatVTON source code
+
+Clone or copy your CatVTON implementation into:
+- `CatVTON/`
+
+If your fork uses a different folder, set:
+- `CATVTON_REPO_DIR`
+
+### 2. Add model weights
+
+Place CatVTON checkpoints in:
+- `checkpoints/CatVTON/`
+
+Or set:
+- `CATVTON_MODEL_DIR`
+
+### 3. Confirm the inference entrypoint
+
+The current app tries common Python and script entrypoints automatically. If your CatVTON fork uses different class names, function names, or CLI arguments, update the loading logic in `app.py`.
+
+### 4. Push to Hugging Face Spaces
+
+After adding the CatVTON repo and weights references, push the repository. Hugging Face will rebuild the Space automatically.
+
+## Frontend integration
+
+Your ecommerce frontend can call the Hugging Face Space directly when needed, making this a free, on-demand approach without keeping a GPU server running continuously.
+
+## Important note
+
+This app is now deployment-ready as a shell, but **real try-on output depends on your exact CatVTON fork and checkpoint format**. If the repository layout differs, `app.py` may need a small adapter for the correct import path or inference call.

.history/README_20260615122003.md

@@ -0,0 +1,74 @@
+---
+title: ChitraTech Virtual Try-On
+emoji: 👕
+colorFrom: pink
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.5.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# ChitraTech Virtual Try-On
+
+This repository is a Hugging Face Space for an on-demand virtual try-on experience powered by **CatVTON**.
+
+## Planned flow
+
+1. A shopper clicks **Try On** on your ecommerce product page.
+2. Your frontend sends the shopper photo and the selected clothing image to this Hugging Face Space.
+3. The Space runs CatVTON inference only for that request.
+4. The generated try-on image is returned to the frontend for preview.
+
+## Current status
+
+The current Space now includes:
+- a Gradio interface for person and garment uploads,
+- lazy pipeline initialization for on-demand inference,
+- automatic detection of CatVTON code under `CatVTON/`,
+- automatic detection of model weights under `checkpoints/CatVTON/`,
+- a safe demo fallback when CatVTON is not fully installed yet.
+
+## Repository structure
+
+Recommended layout:
+- `app.py`
+- `requirements.txt`
+- `CatVTON/` for the cloned CatVTON repository
+- `checkpoints/CatVTON/` for model weights
+- optional `examples/` for demo assets
+
+## Setup steps
+
+### 1. Add CatVTON source code
+
+Clone or copy your CatVTON implementation into:
+- `CatVTON/`
+
+If your fork uses a different folder, set:
+- `CATVTON_REPO_DIR`
+
+### 2. Add model weights
+
+Place CatVTON checkpoints in:
+- `checkpoints/CatVTON/`
+
+Or set:
+- `CATVTON_MODEL_DIR`
+
+### 3. Confirm the inference entrypoint
+
+The current app tries common Python and script entrypoints automatically. If your CatVTON fork uses different class names, function names, or CLI arguments, update the loading logic in `app.py`.
+
+### 4. Push to Hugging Face Spaces
+
+After adding the CatVTON repo and weights references, push the repository. Hugging Face will rebuild the Space automatically.
+
+## Frontend integration
+
+Your ecommerce frontend can call the Hugging Face Space directly when needed, making this a free, on-demand approach without keeping a GPU server running continuously.
+
+## Important note
+
+This app is now deployment-ready as a shell, but **real try-on output depends on your exact CatVTON fork and checkpoint format**. If the repository layout differs, `app.py` may need a small adapter for the correct import path or inference call.

.history/app_20260615121735.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+from PIL import Image, ImageOps, ImageDraw
+
+APP_TITLE = "ChitraTech Virtual Try-On"
+APP_DESCRIPTION = (
+    "Upload a person image and a garment image to run on-demand CatVTON virtual try-on inference. "
+    "This Space is structured so you can swap the placeholder pipeline with your CatVTON model loader and inference code."
+)
+MODEL_DIR = Path(os.getenv("CATVTON_MODEL_DIR", "./checkpoints/CatVTON"))
+DEVICE = os.getenv("CATVTON_DEVICE", "cuda")
+MAX_IMAGE_SIZE = 1024
+
+
+@dataclass
+class CatVTONPipeline:
+    model_dir: Path
+    device: str
+    ready: bool = False
+
+    def load(self) -> None:
+        """Load model weights once when the first request arrives."""
+        # TODO: Replace this placeholder with actual CatVTON imports and checkpoint loading.
+        # Example:
+        # from catvton.inference import CatVTONInferencer
+        # self.model = CatVTONInferencer(checkpoint_path=str(self.model_dir), device=self.device)
+        self.ready = True
+
+    def run(self, person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+        if not self.ready:
+            self.load()
+
+        # TODO: Replace this placeholder with actual CatVTON inference.
+        # Example:
+        # result = self.model.infer(person_image, garment_image)
+        # return result
+        return build_placeholder_preview(person_image, garment_image)
+
+
+pipeline = CatVTONPipeline(model_dir=MODEL_DIR, device=DEVICE)
+
+
+def prepare_image(image: Image.Image) -> Image.Image:
+    image = ImageOps.exif_transpose(image).convert("RGB")
+    image.thumbnail((MAX_IMAGE_SIZE, MAX_IMAGE_SIZE))
+    return image
+
+
+def build_placeholder_preview(person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+    preview = person_image.copy().convert("RGB")
+    garment_thumb = garment_image.copy().convert("RGB")
+    garment_thumb.thumbnail((preview.width // 3, preview.height // 3))
+
+    overlay = Image.new("RGBA", preview.size, (0, 0, 0, 0))
+    x = preview.width - garment_thumb.width - 24
+    y = 24
+    overlay.paste(garment_thumb.convert("RGBA"), (x, y))
+
+    draw = ImageDraw.Draw(overlay)
+    label_y = y + garment_thumb.height + 10
+    draw.rounded_rectangle(
+        [(x, label_y), (min(preview.width - 24, x + 220), label_y + 40)],
+        radius=12,
+        fill=(17, 24, 39, 210),
+    )
+    draw.text((x + 12, label_y + 12), "Placeholder preview", fill=(255, 255, 255, 255))
+
+    return Image.alpha_composite(preview.convert("RGBA"), overlay).convert("RGB")
+
+
+def try_on(person_image: Optional[Image.Image], garment_image: Optional[Image.Image]) -> Image.Image:
+    if person_image is None or garment_image is None:
+        raise gr.Error("Please upload both a person image and a garment image.")
+
+    prepared_person = prepare_image(person_image)
+    prepared_garment = prepare_image(garment_image)
+    return pipeline.run(prepared_person, prepared_garment)
+
+
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(APP_DESCRIPTION)
+
+    with gr.Row():
+        with gr.Column():
+            person_input = gr.Image(type="pil", label="User photo")
+            garment_input = gr.Image(type="pil", label="Clothing image")
+            submit_button = gr.Button("Try On", variant="primary")
+        with gr.Column():
+            result_output = gr.Image(type="pil", label="Generated try-on image")
+
+    gr.Examples(
+        examples=[],
+        inputs=[person_input, garment_input],
+        label="Optional: add example image pairs after you upload assets to the repository.",
+    )
+
+    gr.Markdown(
+        """
+        ### Integration notes
+        - Your ecommerce frontend can call this Space on demand whenever a shopper clicks **Try On**.
+        - Replace the placeholder pipeline with CatVTON inference code and store model weights under `checkpoints/` or download them at startup.
+        - Keep preprocessing logic here so the frontend only needs to send two images.
+        """
+    )
+
+    submit_button.click(fn=try_on, inputs=[person_input, garment_input], outputs=result_output)
+
+
+demo.launch()

.history/app_20260615121752.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+from PIL import Image, ImageOps, ImageDraw
+
+APP_TITLE = "ChitraTech Virtual Try-On"
+APP_DESCRIPTION = (
+    "Upload a person image and a garment image to run on-demand CatVTON virtual try-on inference. "
+    "This Space is structured so you can swap the placeholder pipeline with your CatVTON model loader and inference code."
+)
+MODEL_DIR = Path(os.getenv("CATVTON_MODEL_DIR", "./checkpoints/CatVTON"))
+DEVICE = os.getenv("CATVTON_DEVICE", "cuda")
+MAX_IMAGE_SIZE = 1024
+
+
+@dataclass
+class CatVTONPipeline:
+    model_dir: Path
+    device: str
+    ready: bool = False
+
+    def load(self) -> None:
+        """Load model weights once when the first request arrives."""
+        # TODO: Replace this placeholder with actual CatVTON imports and checkpoint loading.
+        # Example:
+        # from catvton.inference import CatVTONInferencer
+        # self.model = CatVTONInferencer(checkpoint_path=str(self.model_dir), device=self.device)
+        self.ready = True
+
+    def run(self, person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+        if not self.ready:
+            self.load()
+
+        # TODO: Replace this placeholder with actual CatVTON inference.
+        # Example:
+        # result = self.model.infer(person_image, garment_image)
+        # return result
+        return build_placeholder_preview(person_image, garment_image)
+
+
+pipeline = CatVTONPipeline(model_dir=MODEL_DIR, device=DEVICE)
+
+
+def prepare_image(image: Image.Image) -> Image.Image:
+    image = ImageOps.exif_transpose(image).convert("RGB")
+    image.thumbnail((MAX_IMAGE_SIZE, MAX_IMAGE_SIZE))
+    return image
+
+
+def build_placeholder_preview(person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+    preview = person_image.copy().convert("RGB")
+    garment_thumb = garment_image.copy().convert("RGB")
+    garment_thumb.thumbnail((preview.width // 3, preview.height // 3))
+
+    overlay = Image.new("RGBA", preview.size, (0, 0, 0, 0))
+    x = preview.width - garment_thumb.width - 24
+    y = 24
+    overlay.paste(garment_thumb.convert("RGBA"), (x, y))
+
+    draw = ImageDraw.Draw(overlay)
+    label_y = y + garment_thumb.height + 10
+    draw.rounded_rectangle(
+        [(x, label_y), (min(preview.width - 24, x + 220), label_y + 40)],
+        radius=12,
+        fill=(17, 24, 39, 210),
+    )
+    draw.text((x + 12, label_y + 12), "Placeholder preview", fill=(255, 255, 255, 255))
+
+    return Image.alpha_composite(preview.convert("RGBA"), overlay).convert("RGB")
+
+
+def try_on(person_image: Optional[Image.Image], garment_image: Optional[Image.Image]) -> Image.Image:
+    if person_image is None or garment_image is None:
+        raise gr.Error("Please upload both a person image and a garment image.")
+
+    prepared_person = prepare_image(person_image)
+    prepared_garment = prepare_image(garment_image)
+    return pipeline.run(prepared_person, prepared_garment)
+
+
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(APP_DESCRIPTION)
+
+    with gr.Row():
+        with gr.Column():
+            person_input = gr.Image(type="pil", label="User photo")
+            garment_input = gr.Image(type="pil", label="Clothing image")
+            submit_button = gr.Button("Try On", variant="primary")
+        with gr.Column():
+            result_output = gr.Image(type="pil", label="Generated try-on image")
+
+    gr.Examples(
+        examples=[],
+        inputs=[person_input, garment_input],
+        label="Optional: add example image pairs after you upload assets to the repository.",
+    )
+
+    gr.Markdown(
+        """
+        ### Integration notes
+        - Your ecommerce frontend can call this Space on demand whenever a shopper clicks **Try On**.
+        - Replace the placeholder pipeline with CatVTON inference code and store model weights under `checkpoints/` or download them at startup.
+        - Keep preprocessing logic here so the frontend only needs to send two images.
+        """
+    )
+
+    submit_button.click(fn=try_on, inputs=[person_input, garment_input], outputs=result_output)
+
+
+demo.launch()

.history/app_20260615121921.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+from PIL import Image, ImageDraw, ImageOps
+
+APP_TITLE = "ChitraTech Virtual Try-On"
+APP_DESCRIPTION = (
+    "Upload a person image and a garment image to run on-demand CatVTON virtual try-on inference. "
+    "If CatVTON source code and weights are present, the Space uses them automatically; otherwise it falls back to a demo preview."
+)
+MODEL_DIR = Path(os.getenv("CATVTON_MODEL_DIR", "./checkpoints/CatVTON"))
+CATVTON_REPO_DIR = Path(os.getenv("CATVTON_REPO_DIR", "./CatVTON"))
+DEVICE = os.getenv("CATVTON_DEVICE", "cuda")
+MAX_IMAGE_SIZE = 1024
+DEFAULT_STEPS = int(os.getenv("CATVTON_STEPS", "30"))
+DEFAULT_GUIDANCE_SCALE = float(os.getenv("CATVTON_GUIDANCE_SCALE", "2.5"))
+
+
+@dataclass
+class CatVTONPipeline:
+    model_dir: Path
+    repo_dir: Path
+    device: str
+    ready: bool = False
+    backend_name: str = "placeholder"
+    backend_error: Optional[str] = None
+    model: object | None = field(default=None, init=False, repr=False)
+
+    def load(self) -> None:
+        """Load model weights once when the first request arrives."""
+        self.backend_error = None
+
+        if not self.repo_dir.exists():
+            self.backend_name = "placeholder"
+            self.ready = True
+            self.backend_error = (
+                f"CatVTON source folder not found at '{self.repo_dir}'. "
+                "Add the CatVTON repository files there to enable real inference."
+            )
+            return
+
+        if not self.model_dir.exists():
+            self.backend_name = "placeholder"
+            self.ready = True
+            self.backend_error = (
+                f"CatVTON checkpoint folder not found at '{self.model_dir}'. "
+                "Add model weights to enable real inference."
+            )
+            return
+
+        try:
+            if str(self.repo_dir.resolve()) not in sys.path:
+                sys.path.insert(0, str(self.repo_dir.resolve()))
+
+            self.model = self._try_load_native_backend()
+            if self.model is None:
+                self.model = self._try_load_cli_backend()
+
+            if self.model is None:
+                self.backend_name = "placeholder"
+                self.backend_error = (
+                    "CatVTON files were found, but no supported inference entrypoint was detected. "
+                    "Update `_try_load_native_backend` or `_try_load_cli_backend` for your CatVTON fork."
+                )
+            else:
+                self.ready = True
+                return
+        except Exception as exc:  # pragma: no cover - runtime integration path
+            self.backend_name = "placeholder"
+            self.backend_error = f"CatVTON loading failed: {exc}"
+
+        self.ready = True
+
+    def _try_load_native_backend(self) -> object | None:
+        """Try Python-native CatVTON integrations for common repository layouts."""
+        import importlib
+
+        candidates = [
+            ("app", "CatVTONPipeline"),
+            ("inference", "CatVTONPipeline"),
+            ("catvton.inference", "CatVTONPipeline"),
+            ("predict", "Predictor"),
+        ]
+
+        for module_name, class_name in candidates:
+            try:
+                module = importlib.import_module(module_name)
+                backend_class = getattr(module, class_name, None)
+                if backend_class is None:
+                    continue
+                self.backend_name = f"python:{module_name}.{class_name}"
+                return backend_class(model_path=str(self.model_dir), device=self.device)
+            except TypeError:
+                try:
+                    self.backend_name = f"python:{module_name}.{class_name}"
+                    return backend_class(checkpoint_path=str(self.model_dir), device=self.device)
+                except Exception:
+                    continue
+            except Exception:
+                continue
+
+        return None
+
+    def _try_load_cli_backend(self) -> object | None:
+        """Fallback to a subprocess-based backend for CatVTON forks that expose a script."""
+        cli_candidates = [
+            self.repo_dir / "inference.py",
+            self.repo_dir / "predict.py",
+            self.repo_dir / "app.py",
+        ]
+        for script_path in cli_candidates:
+            if script_path.exists():
+                self.backend_name = f"cli:{script_path.name}"
+                return script_path
+        return None
+
+    def run(self, person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+        if not self.ready:
+            self.load()
+
+        if self.backend_name.startswith("python:") and self.model is not None:
+            try:
+                return self._run_python_backend(person_image, garment_image)
+            except Exception as exc:  # pragma: no cover - runtime integration path
+                self.backend_error = f"CatVTON inference failed: {exc}"
+
+        if self.backend_name.startswith("cli:") and self.model is not None:
+            try:
+                return self._run_cli_backend(person_image, garment_image)
+            except Exception as exc:  # pragma: no cover - runtime integration path
+                self.backend_error = f"CatVTON CLI inference failed: {exc}"
+
+        return build_placeholder_preview(person_image, garment_image, self.backend_error)
+
+    def _run_python_backend(self, person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+        assert self.model is not None
+
+        if hasattr(self.model, "infer"):
+            result = self.model.infer(
+                person_image=person_image,
+                garment_image=garment_image,
+                num_inference_steps=DEFAULT_STEPS,
+                guidance_scale=DEFAULT_GUIDANCE_SCALE,
+            )
+        elif callable(self.model):
+            result = self.model(
+                person_image=person_image,
+                garment_image=garment_image,
+                num_inference_steps=DEFAULT_STEPS,
+                guidance_scale=DEFAULT_GUIDANCE_SCALE,
+            )
+        else:
+            raise RuntimeError("Loaded CatVTON backend is not callable.")
+
+        if isinstance(result, Image.Image):
+            return result.convert("RGB")
+        if isinstance(result, dict):
+            for key in ("image", "result", "output"):
+                value = result.get(key)
+                if isinstance(value, Image.Image):
+                    return value.convert("RGB")
+        raise RuntimeError("Unsupported CatVTON output format.")
+
+    def _run_cli_backend(self, person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+        script_path = Path(self.model)
+        input_dir = Path("/tmp/catvton-inputs") if os.name != "nt" else Path("./tmp/catvton-inputs")
+        output_dir = Path("/tmp/catvton-outputs") if os.name != "nt" else Path("./tmp/catvton-outputs")
+        input_dir.mkdir(parents=True, exist_ok=True)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        person_path = input_dir / "person.png"
+        garment_path = input_dir / "garment.png"
+        output_path = output_dir / "result.png"
+        person_image.save(person_path)
+        garment_image.save(garment_path)
+
+        command = [
+            sys.executable,
+            str(script_path),
+            "--person",
+            str(person_path),
+            "--cloth",
+            str(garment_path),
+            "--output",
+            str(output_path),
+            "--checkpoint",
+            str(self.model_dir),
+        ]
+
+        subprocess.run(command, check=True, cwd=str(self.repo_dir))
+        if not output_path.exists():
+            raise RuntimeError("CatVTON CLI completed without writing an output image.")
+        return Image.open(output_path).convert("RGB")
+
+
+pipeline = CatVTONPipeline(model_dir=MODEL_DIR, repo_dir=CATVTON_REPO_DIR, device=DEVICE)
+
+
+def prepare_image(image: Image.Image) -> Image.Image:
+    image = ImageOps.exif_transpose(image).convert("RGB")
+    image.thumbnail((MAX_IMAGE_SIZE, MAX_IMAGE_SIZE))
+    return image
+
+
+def build_placeholder_preview(
+    person_image: Image.Image,
+    garment_image: Image.Image,
+    error_message: Optional[str] = None,
+) -> Image.Image:
+    preview = person_image.copy().convert("RGB")
+    garment_thumb = garment_image.copy().convert("RGB")
+    garment_thumb.thumbnail((preview.width // 3, preview.height // 3))
+
+    overlay = Image.new("RGBA", preview.size, (0, 0, 0, 0))
+    x = preview.width - garment_thumb.width - 24
+    y = 24
+    overlay.paste(garment_thumb.convert("RGBA"), (x, y))
+
+    draw = ImageDraw.Draw(overlay)
+    label_y = y + garment_thumb.height + 10
+    draw.rounded_rectangle(
+        [(x, label_y), (min(preview.width - 24, x + 270), label_y + 44)],
+        radius=12,
+        fill=(17, 24, 39, 210),
+    )
+    draw.text((x + 12, label_y + 13), "Demo preview mode", fill=(255, 255, 255, 255))
+
+    if error_message:
+        panel_top = max(24, preview.height - 170)
+        draw.rounded_rectangle(
+            [(24, panel_top), (preview.width - 24, preview.height - 24)],
+            radius=16,
+            fill=(127, 29, 29, 220),
+        )
+        wrapped = error_message[:180] + ("..." if len(error_message) > 180 else "")
+        draw.text((40, panel_top + 18), wrapped, fill=(255, 255, 255, 255))
+
+    return Image.alpha_composite(preview.convert("RGBA"), overlay).convert("RGB")
+
+
+def try_on(person_image: Optional[Image.Image], garment_image: Optional[Image.Image]) -> Image.Image:
+    if person_image is None or garment_image is None:
+        raise gr.Error("Please upload both a person image and a garment image.")
+
+    prepared_person = prepare_image(person_image)
+    prepared_garment = prepare_image(garment_image)
+    return pipeline.run(prepared_person, prepared_garment)
+
+
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(APP_DESCRIPTION)
+    gr.Markdown(
+        f"**Backend status:** `{pipeline.backend_name}` | Expected source: `{CATVTON_REPO_DIR}` | Expected weights: `{MODEL_DIR}`"
+    )
+
+    with gr.Row():
+        with gr.Column():
+            person_input = gr.Image(type="pil", label="User photo")
+            garment_input = gr.Image(type="pil", label="Clothing image")
+            submit_button = gr.Button("Try On", variant="primary")
+        with gr.Column():
+            result_output = gr.Image(type="pil", label="Generated try-on image")
+
+    gr.Markdown(
+        """
+        ### Setup notes
+        - Put the CatVTON repository code in `CatVTON/` or set `CATVTON_REPO_DIR`.
+        - Put model checkpoints in `checkpoints/CatVTON/` or set `CATVTON_MODEL_DIR`.
+        - If no compatible CatVTON entrypoint is found, the Space stays usable in demo mode.
+        """
+    )
+
+    submit_button.click(fn=try_on, inputs=[person_input, garment_input], outputs=result_output)
+
+
+demo.launch()

.history/app_20260615122003.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+from PIL import Image, ImageDraw, ImageOps
+
+APP_TITLE = "ChitraTech Virtual Try-On"
+APP_DESCRIPTION = (
+    "Upload a person image and a garment image to run on-demand CatVTON virtual try-on inference. "
+    "If CatVTON source code and weights are present, the Space uses them automatically; otherwise it falls back to a demo preview."
+)
+MODEL_DIR = Path(os.getenv("CATVTON_MODEL_DIR", "./checkpoints/CatVTON"))
+CATVTON_REPO_DIR = Path(os.getenv("CATVTON_REPO_DIR", "./CatVTON"))
+DEVICE = os.getenv("CATVTON_DEVICE", "cuda")
+MAX_IMAGE_SIZE = 1024
+DEFAULT_STEPS = int(os.getenv("CATVTON_STEPS", "30"))
+DEFAULT_GUIDANCE_SCALE = float(os.getenv("CATVTON_GUIDANCE_SCALE", "2.5"))
+
+
+@dataclass
+class CatVTONPipeline:
+    model_dir: Path
+    repo_dir: Path
+    device: str
+    ready: bool = False
+    backend_name: str = "placeholder"
+    backend_error: Optional[str] = None
+    model: object | None = field(default=None, init=False, repr=False)
+
+    def load(self) -> None:
+        """Load model weights once when the first request arrives."""
+        self.backend_error = None
+
+        if not self.repo_dir.exists():
+            self.backend_name = "placeholder"
+            self.ready = True
+            self.backend_error = (
+                f"CatVTON source folder not found at '{self.repo_dir}'. "
+                "Add the CatVTON repository files there to enable real inference."
+            )
+            return
+
+        if not self.model_dir.exists():
+            self.backend_name = "placeholder"
+            self.ready = True
+            self.backend_error = (
+                f"CatVTON checkpoint folder not found at '{self.model_dir}'. "
+                "Add model weights to enable real inference."
+            )
+            return
+
+        try:
+            if str(self.repo_dir.resolve()) not in sys.path:
+                sys.path.insert(0, str(self.repo_dir.resolve()))
+
+            self.model = self._try_load_native_backend()
+            if self.model is None:
+                self.model = self._try_load_cli_backend()
+
+            if self.model is None:
+                self.backend_name = "placeholder"
+                self.backend_error = (
+                    "CatVTON files were found, but no supported inference entrypoint was detected. "
+                    "Update `_try_load_native_backend` or `_try_load_cli_backend` for your CatVTON fork."
+                )
+            else:
+                self.ready = True
+                return
+        except Exception as exc:  # pragma: no cover - runtime integration path
+            self.backend_name = "placeholder"
+            self.backend_error = f"CatVTON loading failed: {exc}"
+
+        self.ready = True
+
+    def _try_load_native_backend(self) -> object | None:
+        """Try Python-native CatVTON integrations for common repository layouts."""
+        import importlib
+
+        candidates = [
+            ("app", "CatVTONPipeline"),
+            ("inference", "CatVTONPipeline"),
+            ("catvton.inference", "CatVTONPipeline"),
+            ("predict", "Predictor"),
+        ]
+
+        for module_name, class_name in candidates:
+            try:
+                module = importlib.import_module(module_name)
+                backend_class = getattr(module, class_name, None)
+                if backend_class is None:
+                    continue
+                self.backend_name = f"python:{module_name}.{class_name}"
+                return backend_class(model_path=str(self.model_dir), device=self.device)
+            except TypeError:
+                try:
+                    self.backend_name = f"python:{module_name}.{class_name}"
+                    return backend_class(checkpoint_path=str(self.model_dir), device=self.device)
+                except Exception:
+                    continue
+            except Exception:
+                continue
+
+        return None
+
+    def _try_load_cli_backend(self) -> object | None:
+        """Fallback to a subprocess-based backend for CatVTON forks that expose a script."""
+        cli_candidates = [
+            self.repo_dir / "inference.py",
+            self.repo_dir / "predict.py",
+            self.repo_dir / "app.py",
+        ]
+        for script_path in cli_candidates:
+            if script_path.exists():
+                self.backend_name = f"cli:{script_path.name}"
+                return script_path
+        return None
+
+    def run(self, person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+        if not self.ready:
+            self.load()
+
+        if self.backend_name.startswith("python:") and self.model is not None:
+            try:
+                return self._run_python_backend(person_image, garment_image)
+            except Exception as exc:  # pragma: no cover - runtime integration path
+                self.backend_error = f"CatVTON inference failed: {exc}"
+
+        if self.backend_name.startswith("cli:") and self.model is not None:
+            try:
+                return self._run_cli_backend(person_image, garment_image)
+            except Exception as exc:  # pragma: no cover - runtime integration path
+                self.backend_error = f"CatVTON CLI inference failed: {exc}"
+
+        return build_placeholder_preview(person_image, garment_image, self.backend_error)
+
+    def _run_python_backend(self, person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+        assert self.model is not None
+
+        if hasattr(self.model, "infer"):
+            result = self.model.infer(
+                person_image=person_image,
+                garment_image=garment_image,
+                num_inference_steps=DEFAULT_STEPS,
+                guidance_scale=DEFAULT_GUIDANCE_SCALE,
+            )
+        elif callable(self.model):
+            result = self.model(
+                person_image=person_image,
+                garment_image=garment_image,
+                num_inference_steps=DEFAULT_STEPS,
+                guidance_scale=DEFAULT_GUIDANCE_SCALE,
+            )
+        else:
+            raise RuntimeError("Loaded CatVTON backend is not callable.")
+
+        if isinstance(result, Image.Image):
+            return result.convert("RGB")
+        if isinstance(result, dict):
+            for key in ("image", "result", "output"):
+                value = result.get(key)
+                if isinstance(value, Image.Image):
+                    return value.convert("RGB")
+        raise RuntimeError("Unsupported CatVTON output format.")
+
+    def _run_cli_backend(self, person_image: Image.Image, garment_image: Image.Image) -> Image.Image:
+        script_path = Path(self.model)
+        input_dir = Path("/tmp/catvton-inputs") if os.name != "nt" else Path("./tmp/catvton-inputs")
+        output_dir = Path("/tmp/catvton-outputs") if os.name != "nt" else Path("./tmp/catvton-outputs")
+        input_dir.mkdir(parents=True, exist_ok=True)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        person_path = input_dir / "person.png"
+        garment_path = input_dir / "garment.png"
+        output_path = output_dir / "result.png"
+        person_image.save(person_path)
+        garment_image.save(garment_path)
+
+        command = [
+            sys.executable,
+            str(script_path),
+            "--person",
+            str(person_path),
+            "--cloth",
+            str(garment_path),
+            "--output",
+            str(output_path),
+            "--checkpoint",
+            str(self.model_dir),
+        ]
+
+        subprocess.run(command, check=True, cwd=str(self.repo_dir))
+        if not output_path.exists():
+            raise RuntimeError("CatVTON CLI completed without writing an output image.")
+        return Image.open(output_path).convert("RGB")
+
+
+pipeline = CatVTONPipeline(model_dir=MODEL_DIR, repo_dir=CATVTON_REPO_DIR, device=DEVICE)
+
+
+def prepare_image(image: Image.Image) -> Image.Image:
+    image = ImageOps.exif_transpose(image).convert("RGB")
+    image.thumbnail((MAX_IMAGE_SIZE, MAX_IMAGE_SIZE))
+    return image
+
+
+def build_placeholder_preview(
+    person_image: Image.Image,
+    garment_image: Image.Image,
+    error_message: Optional[str] = None,
+) -> Image.Image:
+    preview = person_image.copy().convert("RGB")
+    garment_thumb = garment_image.copy().convert("RGB")
+    garment_thumb.thumbnail((preview.width // 3, preview.height // 3))
+
+    overlay = Image.new("RGBA", preview.size, (0, 0, 0, 0))
+    x = preview.width - garment_thumb.width - 24
+    y = 24
+    overlay.paste(garment_thumb.convert("RGBA"), (x, y))
+
+    draw = ImageDraw.Draw(overlay)
+    label_y = y + garment_thumb.height + 10
+    draw.rounded_rectangle(
+        [(x, label_y), (min(preview.width - 24, x + 270), label_y + 44)],
+        radius=12,
+        fill=(17, 24, 39, 210),
+    )
+    draw.text((x + 12, label_y + 13), "Demo preview mode", fill=(255, 255, 255, 255))
+
+    if error_message:
+        panel_top = max(24, preview.height - 170)
+        draw.rounded_rectangle(
+            [(24, panel_top), (preview.width - 24, preview.height - 24)],
+            radius=16,
+            fill=(127, 29, 29, 220),
+        )
+        wrapped = error_message[:180] + ("..." if len(error_message) > 180 else "")
+        draw.text((40, panel_top + 18), wrapped, fill=(255, 255, 255, 255))
+
+    return Image.alpha_composite(preview.convert("RGBA"), overlay).convert("RGB")
+
+
+def try_on(person_image: Optional[Image.Image], garment_image: Optional[Image.Image]) -> Image.Image:
+    if person_image is None or garment_image is None:
+        raise gr.Error("Please upload both a person image and a garment image.")
+
+    prepared_person = prepare_image(person_image)
+    prepared_garment = prepare_image(garment_image)
+    return pipeline.run(prepared_person, prepared_garment)
+
+
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(APP_DESCRIPTION)
+    gr.Markdown(
+        f"**Backend status:** `{pipeline.backend_name}` | Expected source: `{CATVTON_REPO_DIR}` | Expected weights: `{MODEL_DIR}`"
+    )
+
+    with gr.Row():
+        with gr.Column():
+            person_input = gr.Image(type="pil", label="User photo")
+            garment_input = gr.Image(type="pil", label="Clothing image")
+            submit_button = gr.Button("Try On", variant="primary")
+        with gr.Column():
+            result_output = gr.Image(type="pil", label="Generated try-on image")
+
+    gr.Markdown(
+        """
+        ### Setup notes
+        - Put the CatVTON repository code in `CatVTON/` or set `CATVTON_REPO_DIR`.
+        - Put model checkpoints in `checkpoints/CatVTON/` or set `CATVTON_MODEL_DIR`.
+        - If no compatible CatVTON entrypoint is found, the Space stays usable in demo mode.
+        """
+    )
+
+    submit_button.click(fn=try_on, inputs=[person_input, garment_input], outputs=result_output)
+
+
+demo.launch()

.history/app_20260615122555.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+import numpy as np
+import torch
+from diffusers.image_processor import VaeImageProcessor
+from huggingface_hub import snapshot_download
+from PIL import Image, ImageOps
+
+APP_TITLE = "ChitraTech Virtual Try-On"
+APP_DESCRIPTION = (
+    "Upload a shopper photo and clothing image to run on-demand CatVTON virtual try-on inference "
+    "using the Zheng-Chong CatVTON implementation."
+)
+CATVTON_REPO_DIR = Path(os.getenv("CATVTON_REPO_DIR", "./CatVTON"))
+CATVTON_RESUME_PATH = os.getenv("CATVTON_RESUME_PATH", "zhengchong/CatVTON")
+CATVTON_BASE_MODEL = os.getenv("CATVTON_BASE_MODEL", "booksforcharlie/stable-diffusion-inpainting")
+CATVTON_OUTPUT_DIR = Path(os.getenv("CATVTON_OUTPUT_DIR", "./outputs"))
+DEVICE = os.getenv("CATVTON_DEVICE", "cuda")
+DEFAULT_WIDTH = int(os.getenv("CATVTON_WIDTH", "768"))
+DEFAULT_HEIGHT = int(os.getenv("CATVTON_HEIGHT", "1024"))
+DEFAULT_STEPS = int(os.getenv("CATVTON_STEPS", "50"))
+DEFAULT_GUIDANCE_SCALE = float(os.getenv("CATVTON_GUIDANCE_SCALE", "2.5"))
+DEFAULT_MIXED_PRECISION = os.getenv("CATVTON_MIXED_PRECISION", "bf16")
+DEFAULT_SEED = int(os.getenv("CATVTON_SEED", "42"))
+
+
+@dataclass
+class CatVTONRuntime:
+    repo_dir: Path
+    device: str
+    pipeline: object | None = field(default=None, init=False, repr=False)
+    automasker: object | None = field(default=None, init=False, repr=False)
+    mask_processor: object | None = field(default=None, init=False, repr=False)
+    resize_and_crop: object | None = field(default=None, init=False, repr=False)
+    resize_and_padding: object | None = field(default=None, init=False, repr=False)
+    vis_mask: object | None = field(default=None, init=False, repr=False)
+    ready: bool = False
+    status: str = "not loaded"
+
+    def load(self) -> None:
+        if self.ready:
+            return
+
+        if not self.repo_dir.exists():
+            raise RuntimeError(f"CatVTON repository not found at '{self.repo_dir}'.")
+
+        repo_path = str(self.repo_dir.resolve())
+        if repo_path not in sys.path:
+            sys.path.insert(0, repo_path)
+
+        from model.cloth_masker import AutoMasker, vis_mask
+        from model.pipeline import CatVTONPipeline
+        from utils import init_weight_dtype, resize_and_crop, resize_and_padding
+
+        repo_weights_dir = Path(snapshot_download(repo_id=CATVTON_RESUME_PATH))
+        self.pipeline = CatVTONPipeline(
+            base_ckpt=CATVTON_BASE_MODEL,
+            attn_ckpt=str(repo_weights_dir),
+            attn_ckpt_version="mix",
+            weight_dtype=init_weight_dtype(DEFAULT_MIXED_PRECISION),
+            use_tf32=True,
+            device=self.device,
+        )
+        self.mask_processor = VaeImageProcessor(
+            vae_scale_factor=8,
+            do_normalize=False,
+            do_binarize=True,
+            do_convert_grayscale=True,
+        )
+        self.automasker = AutoMasker(
+            densepose_ckpt=os.path.join(repo_weights_dir, "DensePose"),
+            schp_ckpt=os.path.join(repo_weights_dir, "SCHP"),
+            device=self.device,
+        )
+        self.resize_and_crop = resize_and_crop
+        self.resize_and_padding = resize_and_padding
+        self.vis_mask = vis_mask
+        CATVTON_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+        self.ready = True
+        self.status = "loaded"
+
+    def run(
+        self,
+        person_image: Image.Image,
+        garment_image: Image.Image,
+        cloth_type: str,
+        num_inference_steps: int,
+        guidance_scale: float,
+        seed: int,
+        show_type: str,
+    ) -> Image.Image:
+        self.load()
+        assert self.pipeline is not None
+        assert self.automasker is not None
+        assert self.mask_processor is not None
+        assert self.resize_and_crop is not None
+        assert self.resize_and_padding is not None
+        assert self.vis_mask is not None
+
+        person_image = self.resize_and_crop(person_image.convert("RGB"), (DEFAULT_WIDTH, DEFAULT_HEIGHT))
+        garment_image = self.resize_and_padding(garment_image.convert("RGB"), (DEFAULT_WIDTH, DEFAULT_HEIGHT))
+
+        generated_mask = self.automasker(person_image, cloth_type)["mask"]
+        generated_mask = self.mask_processor.blur(generated_mask, blur_factor=9)
+
+        generator = None
+        if seed != -1:
+            generator = torch.Generator(device=self.device).manual_seed(seed)
+
+        result_image = self.pipeline(
+            image=person_image,
+            condition_image=garment_image,
+            mask=generated_mask,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            generator=generator,
+        )[0]
+
+        if show_type == "result only":
+            return result_image.convert("RGB")
+
+        masked_person = self.vis_mask(person_image, generated_mask)
+        return compose_preview(person_image, garment_image, masked_person, result_image, show_type)
+
+
+runtime = CatVTONRuntime(repo_dir=CATVTON_REPO_DIR, device=DEVICE)
+
+
+def prepare_image(image: Image.Image) -> Image.Image:
+    return ImageOps.exif_transpose(image).convert("RGB")
+
+
+def image_grid(images: list[Image.Image], rows: int, cols: int) -> Image.Image:
+    if len(images) != rows * cols:
+        raise ValueError("The number of images does not match the grid shape.")
+    width, height = images[0].size
+    grid = Image.new("RGB", size=(cols * width, rows * height))
+    for index, image in enumerate(images):
+        grid.paste(image, box=(index % cols * width, index // cols * height))
+    return grid
+
+
+def compose_preview(
+    person_image: Image.Image,
+    garment_image: Image.Image,
+    masked_person: Image.Image,
+    result_image: Image.Image,
+    show_type: str,
+) -> Image.Image:
+    width, height = person_image.size
+    if show_type == "input & result":
+        side_panel = image_grid([person_image, garment_image], 2, 1).resize((width // 2, height), Image.NEAREST)
+    else:
+        side_panel = image_grid([person_image, masked_person, garment_image], 3, 1).resize((width // 3, height), Image.NEAREST)
+
+    preview = Image.new("RGB", (side_panel.width + 5 + width, height), color=(255, 255, 255))
+    preview.paste(side_panel, (0, 0))
+    preview.paste(result_image.convert("RGB"), (side_panel.width + 5, 0))
+    return preview
+
+
+def try_on(
+    person_image: Optional[Image.Image],
+    garment_image: Optional[Image.Image],
+    cloth_type: str,
+    num_inference_steps: int,
+    guidance_scale: float,
+    seed: int,
+    show_type: str,
+) -> Image.Image:
+    if person_image is None or garment_image is None:
+        raise gr.Error("Please upload both a shopper photo and a clothing image.")
+
+    prepared_person = prepare_image(person_image)
+    prepared_garment = prepare_image(garment_image)
+
+    try:
+        return runtime.run(
+            person_image=prepared_person,
+            garment_image=prepared_garment,
+            cloth_type=cloth_type,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            seed=seed,
+            show_type=show_type,
+        )
+    except Exception as exc:
+        raise gr.Error(f"CatVTON inference failed: {exc}") from exc
+
+
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(APP_DESCRIPTION)
+    gr.Markdown(
+        f"**Runtime:** repo=`{CATVTON_REPO_DIR}` | weights=`{CATVTON_RESUME_PATH}` | device=`{DEVICE}`"
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            person_input = gr.Image(type="pil", label="Shopper photo")
+            garment_input = gr.Image(type="pil", label="Clothing image")
+            cloth_type_input = gr.Radio(
+                label="Garment type",
+                choices=["upper", "lower", "overall"],
+                value="upper",
+            )
+            submit_button = gr.Button("Try On", variant="primary")
+            with gr.Accordion("Advanced options", open=False):
+                step_input = gr.Slider(label="Inference steps", minimum=10, maximum=100, step=5, value=DEFAULT_STEPS)
+                guidance_input = gr.Slider(label="Guidance scale", minimum=0.0, maximum=7.5, step=0.5, value=DEFAULT_GUIDANCE_SCALE)
+                seed_input = gr.Slider(label="Seed", minimum=-1, maximum=10000, step=1, value=DEFAULT_SEED)
+                show_type_input = gr.Radio(
+                    label="Preview mode",
+                    choices=["result only", "input & result", "input & mask & result"],
+                    value="result only",
+                )
+        with gr.Column(scale=1):
+            result_output = gr.Image(type="pil", label="Try-on result")
+
+    gr.Markdown(
+        """
+        ### Notes
+        - This app now uses the real Zheng-Chong `CatVTON/` codebase.
+        - Model weights are downloaded on demand from Hugging Face using `zhengchong/CatVTON` by default.
+        - For commercial use, verify the upstream CatVTON license and model terms before deployment.
+        """
+    )
+
+    submit_button.click(
+        fn=try_on,
+        inputs=[person_input, garment_input, cloth_type_input, step_input, guidance_input, seed_input, show_type_input],
+        outputs=result_output,
+    )
+
+
+demo.queue().launch(show_error=True)

.history/app_20260615122559.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+import numpy as np
+import torch
+from diffusers.image_processor import VaeImageProcessor
+from huggingface_hub import snapshot_download
+from PIL import Image, ImageOps
+
+APP_TITLE = "ChitraTech Virtual Try-On"
+APP_DESCRIPTION = (
+    "Upload a shopper photo and clothing image to run on-demand CatVTON virtual try-on inference "
+    "using the Zheng-Chong CatVTON implementation."
+)
+CATVTON_REPO_DIR = Path(os.getenv("CATVTON_REPO_DIR", "./CatVTON"))
+CATVTON_RESUME_PATH = os.getenv("CATVTON_RESUME_PATH", "zhengchong/CatVTON")
+CATVTON_BASE_MODEL = os.getenv("CATVTON_BASE_MODEL", "booksforcharlie/stable-diffusion-inpainting")
+CATVTON_OUTPUT_DIR = Path(os.getenv("CATVTON_OUTPUT_DIR", "./outputs"))
+DEVICE = os.getenv("CATVTON_DEVICE", "cuda")
+DEFAULT_WIDTH = int(os.getenv("CATVTON_WIDTH", "768"))
+DEFAULT_HEIGHT = int(os.getenv("CATVTON_HEIGHT", "1024"))
+DEFAULT_STEPS = int(os.getenv("CATVTON_STEPS", "50"))
+DEFAULT_GUIDANCE_SCALE = float(os.getenv("CATVTON_GUIDANCE_SCALE", "2.5"))
+DEFAULT_MIXED_PRECISION = os.getenv("CATVTON_MIXED_PRECISION", "bf16")
+DEFAULT_SEED = int(os.getenv("CATVTON_SEED", "42"))
+
+
+@dataclass
+class CatVTONRuntime:
+    repo_dir: Path
+    device: str
+    pipeline: object | None = field(default=None, init=False, repr=False)
+    automasker: object | None = field(default=None, init=False, repr=False)
+    mask_processor: object | None = field(default=None, init=False, repr=False)
+    resize_and_crop: object | None = field(default=None, init=False, repr=False)
+    resize_and_padding: object | None = field(default=None, init=False, repr=False)
+    vis_mask: object | None = field(default=None, init=False, repr=False)
+    ready: bool = False
+    status: str = "not loaded"
+
+    def load(self) -> None:
+        if self.ready:
+            return
+
+        if not self.repo_dir.exists():
+            raise RuntimeError(f"CatVTON repository not found at '{self.repo_dir}'.")
+
+        repo_path = str(self.repo_dir.resolve())
+        if repo_path not in sys.path:
+            sys.path.insert(0, repo_path)
+
+        from model.cloth_masker import AutoMasker, vis_mask
+        from model.pipeline import CatVTONPipeline
+        from utils import init_weight_dtype, resize_and_crop, resize_and_padding
+
+        repo_weights_dir = Path(snapshot_download(repo_id=CATVTON_RESUME_PATH))
+        self.pipeline = CatVTONPipeline(
+            base_ckpt=CATVTON_BASE_MODEL,
+            attn_ckpt=str(repo_weights_dir),
+            attn_ckpt_version="mix",
+            weight_dtype=init_weight_dtype(DEFAULT_MIXED_PRECISION),
+            use_tf32=True,
+            device=self.device,
+        )
+        self.mask_processor = VaeImageProcessor(
+            vae_scale_factor=8,
+            do_normalize=False,
+            do_binarize=True,
+            do_convert_grayscale=True,
+        )
+        self.automasker = AutoMasker(
+            densepose_ckpt=os.path.join(repo_weights_dir, "DensePose"),
+            schp_ckpt=os.path.join(repo_weights_dir, "SCHP"),
+            device=self.device,
+        )
+        self.resize_and_crop = resize_and_crop
+        self.resize_and_padding = resize_and_padding
+        self.vis_mask = vis_mask
+        CATVTON_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+        self.ready = True
+        self.status = "loaded"
+
+    def run(
+        self,
+        person_image: Image.Image,
+        garment_image: Image.Image,
+        cloth_type: str,
+        num_inference_steps: int,
+        guidance_scale: float,
+        seed: int,
+        show_type: str,
+    ) -> Image.Image:
+        self.load()
+        assert self.pipeline is not None
+        assert self.automasker is not None
+        assert self.mask_processor is not None
+        assert self.resize_and_crop is not None
+        assert self.resize_and_padding is not None
+        assert self.vis_mask is not None
+
+        person_image = self.resize_and_crop(person_image.convert("RGB"), (DEFAULT_WIDTH, DEFAULT_HEIGHT))
+        garment_image = self.resize_and_padding(garment_image.convert("RGB"), (DEFAULT_WIDTH, DEFAULT_HEIGHT))
+
+        generated_mask = self.automasker(person_image, cloth_type)["mask"]
+        generated_mask = self.mask_processor.blur(generated_mask, blur_factor=9)
+
+        generator = None
+        if seed != -1:
+            generator = torch.Generator(device=self.device).manual_seed(seed)
+
+        result_image = self.pipeline(
+            image=person_image,
+            condition_image=garment_image,
+            mask=generated_mask,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            generator=generator,
+        )[0]
+
+        if show_type == "result only":
+            return result_image.convert("RGB")
+
+        masked_person = self.vis_mask(person_image, generated_mask)
+        return compose_preview(person_image, garment_image, masked_person, result_image, show_type)
+
+
+runtime = CatVTONRuntime(repo_dir=CATVTON_REPO_DIR, device=DEVICE)
+
+
+def prepare_image(image: Image.Image) -> Image.Image:
+    return ImageOps.exif_transpose(image).convert("RGB")
+
+
+def image_grid(images: list[Image.Image], rows: int, cols: int) -> Image.Image:
+    if len(images) != rows * cols:
+        raise ValueError("The number of images does not match the grid shape.")
+    width, height = images[0].size
+    grid = Image.new("RGB", size=(cols * width, rows * height))
+    for index, image in enumerate(images):
+        grid.paste(image, box=(index % cols * width, index // cols * height))
+    return grid
+
+
+def compose_preview(
+    person_image: Image.Image,
+    garment_image: Image.Image,
+    masked_person: Image.Image,
+    result_image: Image.Image,
+    show_type: str,
+) -> Image.Image:
+    width, height = person_image.size
+    if show_type == "input & result":
+        side_panel = image_grid([person_image, garment_image], 2, 1).resize((width // 2, height), Image.NEAREST)
+    else:
+        side_panel = image_grid([person_image, masked_person, garment_image], 3, 1).resize((width // 3, height), Image.NEAREST)
+
+    preview = Image.new("RGB", (side_panel.width + 5 + width, height), color=(255, 255, 255))
+    preview.paste(side_panel, (0, 0))
+    preview.paste(result_image.convert("RGB"), (side_panel.width + 5, 0))
+    return preview
+
+
+def try_on(
+    person_image: Optional[Image.Image],
+    garment_image: Optional[Image.Image],
+    cloth_type: str,
+    num_inference_steps: int,
+    guidance_scale: float,
+    seed: int,
+    show_type: str,
+) -> Image.Image:
+    if person_image is None or garment_image is None:
+        raise gr.Error("Please upload both a shopper photo and a clothing image.")
+
+    prepared_person = prepare_image(person_image)
+    prepared_garment = prepare_image(garment_image)
+
+    try:
+        return runtime.run(
+            person_image=prepared_person,
+            garment_image=prepared_garment,
+            cloth_type=cloth_type,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            seed=seed,
+            show_type=show_type,
+        )
+    except Exception as exc:
+        raise gr.Error(f"CatVTON inference failed: {exc}") from exc
+
+
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(APP_DESCRIPTION)
+    gr.Markdown(
+        f"**Runtime:** repo=`{CATVTON_REPO_DIR}` | weights=`{CATVTON_RESUME_PATH}` | device=`{DEVICE}`"
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            person_input = gr.Image(type="pil", label="Shopper photo")
+            garment_input = gr.Image(type="pil", label="Clothing image")
+            cloth_type_input = gr.Radio(
+                label="Garment type",
+                choices=["upper", "lower", "overall"],
+                value="upper",
+            )
+            submit_button = gr.Button("Try On", variant="primary")
+            with gr.Accordion("Advanced options", open=False):
+                step_input = gr.Slider(label="Inference steps", minimum=10, maximum=100, step=5, value=DEFAULT_STEPS)
+                guidance_input = gr.Slider(label="Guidance scale", minimum=0.0, maximum=7.5, step=0.5, value=DEFAULT_GUIDANCE_SCALE)
+                seed_input = gr.Slider(label="Seed", minimum=-1, maximum=10000, step=1, value=DEFAULT_SEED)
+                show_type_input = gr.Radio(
+                    label="Preview mode",
+                    choices=["result only", "input & result", "input & mask & result"],
+                    value="result only",
+                )
+        with gr.Column(scale=1):
+            result_output = gr.Image(type="pil", label="Try-on result")
+
+    gr.Markdown(
+        """
+        ### Notes
+        - This app now uses the real Zheng-Chong `CatVTON/` codebase.
+        - Model weights are downloaded on demand from Hugging Face using `zhengchong/CatVTON` by default.
+        - For commercial use, verify the upstream CatVTON license and model terms before deployment.
+        """
+    )
+
+    submit_button.click(
+        fn=try_on,
+        inputs=[person_input, garment_input, cloth_type_input, step_input, guidance_input, seed_input, show_type_input],
+        outputs=result_output,
+    )
+
+
+demo.queue().launch(show_error=True)

.history/requirements_20260615121839.txt

@@ -0,0 +1,12 @@
+gradio==6.5.1
+pillow>=10.0.0
+numpy>=1.26.0
+torch>=2.3.0
+torchvision>=0.18.0
+transformers>=4.40.0
+accelerate>=0.30.0
+diffusers>=0.29.0
+safetensors>=0.4.3
+huggingface_hub>=0.23.0
+opencv-python-headless>=4.9.0.80
+scikit-image>=0.22.0

.history/requirements_20260615122003.txt

@@ -0,0 +1,12 @@
+gradio==6.5.1
+pillow>=10.0.0
+numpy>=1.26.0
+torch>=2.3.0
+torchvision>=0.18.0
+transformers>=4.40.0
+accelerate>=0.30.0
+diffusers>=0.29.0
+safetensors>=0.4.3
+huggingface_hub>=0.23.0
+opencv-python-headless>=4.9.0.80
+scikit-image>=0.22.0

.history/requirements_20260615122555.txt

@@ -0,0 +1,23 @@
+torch==2.4.0
+torchvision==0.19.0
+accelerate==0.31.0
+git+https://github.com/huggingface/diffusers.git
+matplotlib==3.9.1
+numpy==1.26.4
+opencv-python-headless==4.10.0.84
+pillow==10.3.0
+PyYAML==6.0.1
+scipy==1.13.1
+setuptools==51.0.0
+scikit-image==0.24.0
+tqdm==4.66.4
+transformers==4.46.3
+fvcore==0.1.5.post20221221
+cloudpickle==3.0.0
+omegaconf==2.3.0
+pycocotools==2.0.8
+av==12.3.0
+gradio==4.41.0
+peft>=0.17.0
+huggingface_hub>=0.34.0,<2.0
+safetensors>=0.4.3

.history/requirements_20260615122559.txt

@@ -0,0 +1,23 @@
+torch==2.4.0
+torchvision==0.19.0
+accelerate==0.31.0
+git+https://github.com/huggingface/diffusers.git
+matplotlib==3.9.1
+numpy==1.26.4
+opencv-python-headless==4.10.0.84
+pillow==10.3.0
+PyYAML==6.0.1
+scipy==1.13.1
+setuptools==51.0.0
+scikit-image==0.24.0
+tqdm==4.66.4
+transformers==4.46.3
+fvcore==0.1.5.post20221221
+cloudpickle==3.0.0
+omegaconf==2.3.0
+pycocotools==2.0.8
+av==12.3.0
+gradio==4.41.0
+peft>=0.17.0
+huggingface_hub>=0.34.0,<2.0
+safetensors>=0.4.3

CatVTON

@@ -0,0 +1 @@
+Subproject commit 7818397f25613beedb3d861a34769f607cfcf3b1

README.md

@@ -1,16 +1,74 @@
 ---
-title: ChitraTech
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
+title: ChitraTech Virtual Try-On
+emoji: 👕
+colorFrom: pink
+colorTo: indigo
 sdk: gradio
 sdk_version: 6.5.1
 app_file: app.py
 pinned: false
-hf_oauth: true
-hf_oauth_scopes:
-- inference-api
 license: mit
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# ChitraTech Virtual Try-On
+
+This repository is a Hugging Face Space for an on-demand virtual try-on experience powered by **CatVTON**.
+
+## Planned flow
+
+1. A shopper clicks **Try On** on your ecommerce product page.
+2. Your frontend sends the shopper photo and the selected clothing image to this Hugging Face Space.
+3. The Space runs CatVTON inference only for that request.
+4. The generated try-on image is returned to the frontend for preview.
+
+## Current status
+
+The current Space now includes:
+- a Gradio interface for person and garment uploads,
+- lazy pipeline initialization for on-demand inference,
+- automatic detection of CatVTON code under `CatVTON/`,
+- automatic detection of model weights under `checkpoints/CatVTON/`,
+- a safe demo fallback when CatVTON is not fully installed yet.
+
+## Repository structure
+
+Recommended layout:
+- `app.py`
+- `requirements.txt`
+- `CatVTON/` for the cloned CatVTON repository
+- `checkpoints/CatVTON/` for model weights
+- optional `examples/` for demo assets
+
+## Setup steps
+
+### 1. Add CatVTON source code
+
+Clone or copy your CatVTON implementation into:
+- `CatVTON/`
+
+If your fork uses a different folder, set:
+- `CATVTON_REPO_DIR`
+
+### 2. Add model weights
+
+Place CatVTON checkpoints in:
+- `checkpoints/CatVTON/`
+
+Or set:
+- `CATVTON_MODEL_DIR`
+
+### 3. Confirm the inference entrypoint
+
+The current app tries common Python and script entrypoints automatically. If your CatVTON fork uses different class names, function names, or CLI arguments, update the loading logic in `app.py`.
+
+### 4. Push to Hugging Face Spaces
+
+After adding the CatVTON repo and weights references, push the repository. Hugging Face will rebuild the Space automatically.
+
+## Frontend integration
+
+Your ecommerce frontend can call the Hugging Face Space directly when needed, making this a free, on-demand approach without keeping a GPU server running continuously.
+
+## Important note
+
+This app is now deployment-ready as a shell, but **real try-on output depends on your exact CatVTON fork and checkpoint format**. If the repository layout differs, `app.py` may need a small adapter for the correct import path or inference call.

app.py

@@ -1,16 +1,243 @@
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
 import gradio as gr
+import numpy as np
+import torch
+from diffusers.image_processor import VaeImageProcessor
+from huggingface_hub import snapshot_download
+from PIL import Image, ImageOps
 
-def try_on(person, cloth):
-    return person
-
-demo = gr.Interface(
-    fn=try_on,
-    inputs=[
-        gr.Image(type="pil"),
-        gr.Image(type="pil")
-    ],
-    outputs="image",
-    title="CP-VTON Test Demo"
+APP_TITLE = "ChitraTech Virtual Try-On"
+APP_DESCRIPTION = (
+    "Upload a shopper photo and clothing image to run on-demand CatVTON virtual try-on inference "
+    "using the Zheng-Chong CatVTON implementation."
 )
+CATVTON_REPO_DIR = Path(os.getenv("CATVTON_REPO_DIR", "./CatVTON"))
+CATVTON_RESUME_PATH = os.getenv("CATVTON_RESUME_PATH", "zhengchong/CatVTON")
+CATVTON_BASE_MODEL = os.getenv("CATVTON_BASE_MODEL", "booksforcharlie/stable-diffusion-inpainting")
+CATVTON_OUTPUT_DIR = Path(os.getenv("CATVTON_OUTPUT_DIR", "./outputs"))
+DEVICE = os.getenv("CATVTON_DEVICE", "cuda")
+DEFAULT_WIDTH = int(os.getenv("CATVTON_WIDTH", "768"))
+DEFAULT_HEIGHT = int(os.getenv("CATVTON_HEIGHT", "1024"))
+DEFAULT_STEPS = int(os.getenv("CATVTON_STEPS", "50"))
+DEFAULT_GUIDANCE_SCALE = float(os.getenv("CATVTON_GUIDANCE_SCALE", "2.5"))
+DEFAULT_MIXED_PRECISION = os.getenv("CATVTON_MIXED_PRECISION", "bf16")
+DEFAULT_SEED = int(os.getenv("CATVTON_SEED", "42"))
+
+
+@dataclass
+class CatVTONRuntime:
+    repo_dir: Path
+    device: str
+    pipeline: object | None = field(default=None, init=False, repr=False)
+    automasker: object | None = field(default=None, init=False, repr=False)
+    mask_processor: object | None = field(default=None, init=False, repr=False)
+    resize_and_crop: object | None = field(default=None, init=False, repr=False)
+    resize_and_padding: object | None = field(default=None, init=False, repr=False)
+    vis_mask: object | None = field(default=None, init=False, repr=False)
+    ready: bool = False
+    status: str = "not loaded"
+
+    def load(self) -> None:
+        if self.ready:
+            return
+
+        if not self.repo_dir.exists():
+            raise RuntimeError(f"CatVTON repository not found at '{self.repo_dir}'.")
+
+        repo_path = str(self.repo_dir.resolve())
+        if repo_path not in sys.path:
+            sys.path.insert(0, repo_path)
+
+        from model.cloth_masker import AutoMasker, vis_mask
+        from model.pipeline import CatVTONPipeline
+        from utils import init_weight_dtype, resize_and_crop, resize_and_padding
+
+        repo_weights_dir = Path(snapshot_download(repo_id=CATVTON_RESUME_PATH))
+        self.pipeline = CatVTONPipeline(
+            base_ckpt=CATVTON_BASE_MODEL,
+            attn_ckpt=str(repo_weights_dir),
+            attn_ckpt_version="mix",
+            weight_dtype=init_weight_dtype(DEFAULT_MIXED_PRECISION),
+            use_tf32=True,
+            device=self.device,
+        )
+        self.mask_processor = VaeImageProcessor(
+            vae_scale_factor=8,
+            do_normalize=False,
+            do_binarize=True,
+            do_convert_grayscale=True,
+        )
+        self.automasker = AutoMasker(
+            densepose_ckpt=os.path.join(repo_weights_dir, "DensePose"),
+            schp_ckpt=os.path.join(repo_weights_dir, "SCHP"),
+            device=self.device,
+        )
+        self.resize_and_crop = resize_and_crop
+        self.resize_and_padding = resize_and_padding
+        self.vis_mask = vis_mask
+        CATVTON_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+        self.ready = True
+        self.status = "loaded"
+
+    def run(
+        self,
+        person_image: Image.Image,
+        garment_image: Image.Image,
+        cloth_type: str,
+        num_inference_steps: int,
+        guidance_scale: float,
+        seed: int,
+        show_type: str,
+    ) -> Image.Image:
+        self.load()
+        assert self.pipeline is not None
+        assert self.automasker is not None
+        assert self.mask_processor is not None
+        assert self.resize_and_crop is not None
+        assert self.resize_and_padding is not None
+        assert self.vis_mask is not None
+
+        person_image = self.resize_and_crop(person_image.convert("RGB"), (DEFAULT_WIDTH, DEFAULT_HEIGHT))
+        garment_image = self.resize_and_padding(garment_image.convert("RGB"), (DEFAULT_WIDTH, DEFAULT_HEIGHT))
+
+        generated_mask = self.automasker(person_image, cloth_type)["mask"]
+        generated_mask = self.mask_processor.blur(generated_mask, blur_factor=9)
+
+        generator = None
+        if seed != -1:
+            generator = torch.Generator(device=self.device).manual_seed(seed)
+
+        result_image = self.pipeline(
+            image=person_image,
+            condition_image=garment_image,
+            mask=generated_mask,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            generator=generator,
+        )[0]
+
+        if show_type == "result only":
+            return result_image.convert("RGB")
+
+        masked_person = self.vis_mask(person_image, generated_mask)
+        return compose_preview(person_image, garment_image, masked_person, result_image, show_type)
+
+
+runtime = CatVTONRuntime(repo_dir=CATVTON_REPO_DIR, device=DEVICE)
+
+
+def prepare_image(image: Image.Image) -> Image.Image:
+    return ImageOps.exif_transpose(image).convert("RGB")
+
+
+def image_grid(images: list[Image.Image], rows: int, cols: int) -> Image.Image:
+    if len(images) != rows * cols:
+        raise ValueError("The number of images does not match the grid shape.")
+    width, height = images[0].size
+    grid = Image.new("RGB", size=(cols * width, rows * height))
+    for index, image in enumerate(images):
+        grid.paste(image, box=(index % cols * width, index // cols * height))
+    return grid
+
+
+def compose_preview(
+    person_image: Image.Image,
+    garment_image: Image.Image,
+    masked_person: Image.Image,
+    result_image: Image.Image,
+    show_type: str,
+) -> Image.Image:
+    width, height = person_image.size
+    if show_type == "input & result":
+        side_panel = image_grid([person_image, garment_image], 2, 1).resize((width // 2, height), Image.NEAREST)
+    else:
+        side_panel = image_grid([person_image, masked_person, garment_image], 3, 1).resize((width // 3, height), Image.NEAREST)
+
+    preview = Image.new("RGB", (side_panel.width + 5 + width, height), color=(255, 255, 255))
+    preview.paste(side_panel, (0, 0))
+    preview.paste(result_image.convert("RGB"), (side_panel.width + 5, 0))
+    return preview
+
+
+def try_on(
+    person_image: Optional[Image.Image],
+    garment_image: Optional[Image.Image],
+    cloth_type: str,
+    num_inference_steps: int,
+    guidance_scale: float,
+    seed: int,
+    show_type: str,
+) -> Image.Image:
+    if person_image is None or garment_image is None:
+        raise gr.Error("Please upload both a shopper photo and a clothing image.")
+
+    prepared_person = prepare_image(person_image)
+    prepared_garment = prepare_image(garment_image)
+
+    try:
+        return runtime.run(
+            person_image=prepared_person,
+            garment_image=prepared_garment,
+            cloth_type=cloth_type,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            seed=seed,
+            show_type=show_type,
+        )
+    except Exception as exc:
+        raise gr.Error(f"CatVTON inference failed: {exc}") from exc
+
+
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(APP_DESCRIPTION)
+    gr.Markdown(
+        f"**Runtime:** repo=`{CATVTON_REPO_DIR}` | weights=`{CATVTON_RESUME_PATH}` | device=`{DEVICE}`"
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            person_input = gr.Image(type="pil", label="Shopper photo")
+            garment_input = gr.Image(type="pil", label="Clothing image")
+            cloth_type_input = gr.Radio(
+                label="Garment type",
+                choices=["upper", "lower", "overall"],
+                value="upper",
+            )
+            submit_button = gr.Button("Try On", variant="primary")
+            with gr.Accordion("Advanced options", open=False):
+                step_input = gr.Slider(label="Inference steps", minimum=10, maximum=100, step=5, value=DEFAULT_STEPS)
+                guidance_input = gr.Slider(label="Guidance scale", minimum=0.0, maximum=7.5, step=0.5, value=DEFAULT_GUIDANCE_SCALE)
+                seed_input = gr.Slider(label="Seed", minimum=-1, maximum=10000, step=1, value=DEFAULT_SEED)
+                show_type_input = gr.Radio(
+                    label="Preview mode",
+                    choices=["result only", "input & result", "input & mask & result"],
+                    value="result only",
+                )
+        with gr.Column(scale=1):
+            result_output = gr.Image(type="pil", label="Try-on result")
+
+    gr.Markdown(
+        """
+        ### Notes
+        - This app now uses the real Zheng-Chong `CatVTON/` codebase.
+        - Model weights are downloaded on demand from Hugging Face using `zhengchong/CatVTON` by default.
+        - For commercial use, verify the upstream CatVTON license and model terms before deployment.
+        """
+    )
+
+    submit_button.click(
+        fn=try_on,
+        inputs=[person_input, garment_input, cloth_type_input, step_input, guidance_input, seed_input, show_type_input],
+        outputs=result_output,
+    )
+
 
-demo.launch()
+demo.queue().launch(show_error=True)

requirements.txt

@@ -0,0 +1,23 @@
+torch==2.4.0
+torchvision==0.19.0
+accelerate==0.31.0
+git+https://github.com/huggingface/diffusers.git
+matplotlib==3.9.1
+numpy==1.26.4
+opencv-python-headless==4.10.0.84
+pillow==10.3.0
+PyYAML==6.0.1
+scipy==1.13.1
+setuptools==51.0.0
+scikit-image==0.24.0
+tqdm==4.66.4
+transformers==4.46.3
+fvcore==0.1.5.post20221221
+cloudpickle==3.0.0
+omegaconf==2.3.0
+pycocotools==2.0.8
+av==12.3.0
+gradio==4.41.0
+peft>=0.17.0
+huggingface_hub>=0.34.0,<2.0
+safetensors>=0.4.3