Clean up demo: real faces, simplified UI, remove bloat

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+examples/demo_face_1.png filter=lfs diff=lfs merge=lfs -text
+examples/demo_face_2.png filter=lfs diff=lfs merge=lfs -text
+examples/demo_face_3.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,14 +1,10 @@
-"""LandmarkDiff Hugging Face Spaces Demo - TPS-only (CPU)."""
+"""LandmarkDiff -- Facial surgery outcome prediction demo (TPS on CPU)."""
 
 from __future__ import annotations
 
-import json
 import logging
-import os
-import threading
 import time
 import traceback
-from datetime import datetime, timezone
 from pathlib import Path
 
 import cv2
@@ -23,137 +19,21 @@ from landmarkdiff.masking import generate_surgical_mask
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-VERSION = "v0.2.2"
-
 GITHUB_URL = "https://github.com/dreamlessx/LandmarkDiff-public"
-DOCS_URL = f"{GITHUB_URL}/tree/main/docs"
-WIKI_URL = f"{GITHUB_URL}/wiki"
-DISCUSSIONS_URL = f"{GITHUB_URL}/discussions"
-
-PROCEDURE_DESCRIPTIONS = {
-    "rhinoplasty": "Nose reshaping -- adjusts nasal bridge, tip projection, and alar width",
-    "blepharoplasty": "Eyelid surgery -- modifies upper/lower lid position and canthal tilt",
-    "rhytidectomy": "Facelift -- tightens midface and jawline contours",
-    "orthognathic": "Jaw surgery -- repositions maxilla and mandible for skeletal alignment",
-    "brow_lift": "Brow lift -- elevates brow position and reduces forehead ptosis",
-    "mentoplasty": "Chin surgery -- adjusts chin projection and vertical height",
-}
+PROCEDURES = list(PROCEDURE_LANDMARKS.keys())
+EXAMPLE_DIR = Path(__file__).parent / "examples"
+EXAMPLE_IMAGES = sorted(EXAMPLE_DIR.glob("*.png")) if EXAMPLE_DIR.exists() else []
 
-# -- Detailed procedure info shown when user selects a procedure --
-PROCEDURE_DETAILS = {
-    "rhinoplasty": (
-        "**Rhinoplasty** (nose reshaping)\n\n"
-        "Modifies the nasal bridge height, tip projection, tip rotation, and alar (nostril) "
-        "width. The landmark displacement targets the nose dorsum, tip, columella, and alar "
-        "base regions. At low intensity (10-30%) the effect is subtle refinement; at high "
-        "intensity (70-100%) the reshaping is more dramatic.\n\n"
-        "Affected landmarks: nasal bridge, tip, alar base, columella"
-    ),
-    "blepharoplasty": (
-        "**Blepharoplasty** (eyelid surgery)\n\n"
-        "Adjusts upper and lower eyelid position and canthal tilt. Targets the periorbital "
-        "region including upper lid crease, lower lid margin, and lateral/medial canthi. "
-        "Simulates both upper blepharoplasty (lid ptosis correction) and lower blepharoplasty "
-        "(under-eye bag removal).\n\n"
-        "Affected landmarks: upper/lower eyelid margins, canthi, periorbital region"
-    ),
-    "rhytidectomy": (
-        "**Rhytidectomy** (facelift)\n\n"
-        "Tightens the midface and jawline by displacing landmarks along vectors that simulate "
-        "SMAS lift and skin redraping. Affects the cheek, jowl, and submental regions. The "
-        "effect tightens nasolabial folds and redefines the jawline contour.\n\n"
-        "Affected landmarks: cheek, jowl, jawline, submental region"
-    ),
-    "orthognathic": (
-        "**Orthognathic surgery** (jaw repositioning)\n\n"
-        "Simulates maxillary and mandibular osteotomy outcomes by repositioning the skeletal "
-        "framework. Affects jaw position, chin projection, and overall facial proportion. "
-        "Used for correcting class II/III malocclusion and facial asymmetry.\n\n"
-        "Affected landmarks: maxilla, mandible, chin, lower face contour"
-    ),
-    "brow_lift": (
-        "**Brow lift** (forehead rejuvenation)\n\n"
-        "Elevates brow position and reduces forehead ptosis. Targets the eyebrow arch, "
-        "lateral brow tail, and glabellar region. Simulates both endoscopic and coronal "
-        "brow lift approaches. Higher intensities produce more visible brow elevation.\n\n"
-        "Affected landmarks: brow arch, lateral brow, glabella, upper forehead"
-    ),
-    "mentoplasty": (
-        "**Mentoplasty** (chin surgery)\n\n"
-        "Adjusts chin projection (anteroposterior position) and vertical height. Simulates "
-        "both augmentation (advancement) and reduction genioplasty. Affects the pogonion, "
-        "menton, and lower border of the mandible.\n\n"
-        "Affected landmarks: chin point, lower mandibular border, mentolabial fold"
-    ),
+PROCEDURE_INFO = {
+    "rhinoplasty": "Nose reshaping (bridge, tip, alar width)",
+    "blepharoplasty": "Eyelid surgery (lid position, canthal tilt)",
+    "rhytidectomy": "Facelift (midface, jawline tightening)",
+    "orthognathic": "Jaw surgery (maxilla/mandible repositioning)",
+    "brow_lift": "Brow elevation, forehead ptosis reduction",
+    "mentoplasty": "Chin surgery (projection, vertical height)",
 }
 
 
-# ---------------------------------------------------------------------------
-# Usage analytics -- simple thread-safe counter persisted to disk
-# ---------------------------------------------------------------------------
-class UsageTracker:
-    """Track demo usage counts to a JSON file (thread-safe)."""
-
-    def __init__(self, path: str = "usage_stats.json"):
-        self._path = Path(path)
-        self._lock = threading.Lock()
-        self._stats: dict = self._load()
-
-    def _load(self) -> dict:
-        if self._path.exists():
-            try:
-                return json.loads(self._path.read_text())
-            except (json.JSONDecodeError, OSError):
-                pass
-        return {
-            "total_runs": 0,
-            "procedures": {},
-            "tabs": {},
-            "first_run": None,
-            "last_run": None,
-        }
-
-    def _save(self) -> None:
-        try:
-            self._path.write_text(json.dumps(self._stats, indent=2))
-        except OSError:
-            logger.warning("Could not persist usage stats")
-
-    def record(self, tab: str, procedure: str | None = None) -> None:
-        with self._lock:
-            now = datetime.now(timezone.utc).isoformat()
-            self._stats["total_runs"] = self._stats.get("total_runs", 0) + 1
-            if self._stats.get("first_run") is None:
-                self._stats["first_run"] = now
-            self._stats["last_run"] = now
-
-            tabs = self._stats.setdefault("tabs", {})
-            tabs[tab] = tabs.get(tab, 0) + 1
-
-            if procedure:
-                procs = self._stats.setdefault("procedures", {})
-                procs[procedure] = procs.get(procedure, 0) + 1
-
-            self._save()
-
-    @property
-    def total_runs(self) -> int:
-        return self._stats.get("total_runs", 0)
-
-    @property
-    def summary(self) -> str:
-        total = self._stats.get("total_runs", 0)
-        top_proc = ""
-        procs = self._stats.get("procedures", {})
-        if procs:
-            top = max(procs, key=procs.get)
-            top_proc = f" | Most popular: {top.replace('_', ' ').title()}"
-        return f"Total runs: {total}{top_proc}"
-
-
-tracker = UsageTracker()
-
-
 def warp_image_tps(image, src_pts, dst_pts):
     """Thin-plate spline warp (CPU only)."""
     from landmarkdiff.synthetic.tps_warp import warp_image_tps as _warp
@@ -161,18 +41,12 @@ def warp_image_tps(image, src_pts, dst_pts):
     return _warp(image, src_pts, dst_pts)
 
 
-def mask_composite(warped, original, mask):
-    """Alpha blend warped into original using mask."""
-    mask_3 = np.stack([mask] * 3, axis=-1) if mask.ndim == 2 else mask
-    return (warped * mask_3 + original * (1.0 - mask_3)).astype(np.uint8)
-
-
 def resize_preserve_aspect(image, size=512):
-    """Resize image to size x size, padding to preserve aspect ratio."""
+    """Resize to square canvas, padding to preserve aspect ratio."""
     h, w = image.shape[:2]
     scale = size / max(h, w)
     new_w, new_h = int(w * scale), int(h * scale)
-    resized = cv2.resize(image, (new_w, new_h))
+    resized = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_LANCZOS4)
     canvas = np.zeros((size, size, 3), dtype=np.uint8)
     y_off = (size - new_h) // 2
     x_off = (size - new_w) // 2
@@ -180,26 +54,21 @@ def resize_preserve_aspect(image, size=512):
     return canvas
 
 
-PROCEDURES = list(PROCEDURE_LANDMARKS.keys())
-
-
-def _error_result(msg):
-    """Return a 5-tuple of blanks + error message for the UI."""
-    blank = np.zeros((512, 512, 3), dtype=np.uint8)
-    return blank, blank, blank, blank, msg
+def mask_composite(warped, original, mask):
+    """Alpha-blend warped region into original using mask."""
+    mask_3 = np.stack([mask] * 3, axis=-1) if mask.ndim == 2 else mask
+    return (warped * mask_3 + original * (1.0 - mask_3)).astype(np.uint8)
 
 
-def _get_procedure_description(procedure: str) -> str:
-    """Return the detailed Markdown description for a procedure."""
-    return PROCEDURE_DETAILS.get(procedure, "Select a procedure to see details.")
+def _blank():
+    return np.zeros((512, 512, 3), dtype=np.uint8)
 
 
 def process_image(image_rgb, procedure, intensity):
-    """Process a single image through the TPS pipeline."""
-    tracker.record("single", procedure)
-
+    """Run the TPS pipeline on a single image."""
     if image_rgb is None:
-        return _error_result("Upload a face photo to begin.")
+        b = _blank()
+        return b, b, b, b, "Upload a face photo to begin."
 
     t0 = time.monotonic()
 
@@ -209,31 +78,29 @@ def process_image(image_rgb, procedure, intensity):
         image_rgb_512 = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
     except Exception as exc:
         logger.error("Image conversion failed: %s", exc)
-        return _error_result(f"Image conversion failed: {exc}")
+        b = _blank()
+        return b, b, b, b, f"Image conversion failed: {exc}"
 
     try:
         face = extract_landmarks(image_bgr)
     except Exception as exc:
         logger.error("Landmark extraction failed: %s\n%s", exc, traceback.format_exc())
-        return _error_result(f"Landmark extraction error: {exc}")
+        b = _blank()
+        return b, b, b, b, f"Landmark extraction error: {exc}"
 
     if face is None:
         return (
-            image_rgb_512,
-            image_rgb_512,
-            image_rgb_512,
-            image_rgb_512,
-            "No face detected. Try a clearer photo with good lighting.",
+            image_rgb_512, image_rgb_512, image_rgb_512, image_rgb_512,
+            "No face detected. Try a clearer, well-lit frontal photo.",
         )
 
     try:
         manipulated = apply_procedure_preset(face, procedure, float(intensity), image_size=512)
-
         wireframe = render_wireframe(manipulated, width=512, height=512)
         wireframe_rgb = cv2.cvtColor(wireframe, cv2.COLOR_GRAY2RGB)
 
         mask = generate_surgical_mask(face, procedure, 512, 512)
-        mask_vis = (mask * 255).astype(np.uint8)
+        mask_vis = cv2.cvtColor((mask * 255).astype(np.uint8), cv2.COLOR_GRAY2RGB)
 
         warped = warp_image_tps(image_bgr, face.pixel_coords, manipulated.pixel_coords)
         composited = mask_composite(warped, image_bgr, mask)
@@ -242,38 +109,32 @@ def process_image(image_rgb, procedure, intensity):
         displacement = np.mean(
             np.linalg.norm(manipulated.pixel_coords - face.pixel_coords, axis=1)
         )
-
         elapsed = time.monotonic() - t0
 
         info = (
-            f"Procedure: {procedure}\n"
+            f"Procedure: {procedure.replace('_', ' ').title()}\n"
             f"Intensity: {intensity:.0f}%\n"
             f"Landmarks: {len(face.landmarks)}\n"
             f"Avg displacement: {displacement:.1f} px\n"
             f"Confidence: {face.confidence:.2f}\n"
-            f"Processing time: {elapsed:.2f}s\n"
-            f"Mode: TPS (CPU)"
+            f"Time: {elapsed:.2f}s | Mode: TPS (CPU)"
         )
-        # Return original as 4th output instead of stretched side-by-side
         return wireframe_rgb, mask_vis, composited_rgb, image_rgb_512, info
 
     except Exception as exc:
         logger.error("Processing failed: %s\n%s", exc, traceback.format_exc())
-        return _error_result(f"Processing error: {exc}")
+        b = _blank()
+        return b, b, b, b, f"Processing error: {exc}"
 
 
 def compare_procedures(image_rgb, intensity):
-    """Compare all procedures at the same intensity."""
-    tracker.record("compare")
-
+    """Compare all six procedures at the same intensity."""
     if image_rgb is None:
-        blank = np.zeros((512, 512, 3), dtype=np.uint8)
-        return [blank] * len(PROCEDURES)
+        return [_blank()] * len(PROCEDURES)
 
     try:
         image_bgr = cv2.cvtColor(np.asarray(image_rgb, dtype=np.uint8), cv2.COLOR_RGB2BGR)
         image_bgr = resize_preserve_aspect(image_bgr, 512)
-
         face = extract_landmarks(image_bgr)
         if face is None:
             rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
@@ -286,32 +147,26 @@ def compare_procedures(image_rgb, intensity):
             warped = warp_image_tps(image_bgr, face.pixel_coords, manip.pixel_coords)
             comp = mask_composite(warped, image_bgr, mask)
             results.append(cv2.cvtColor(comp, cv2.COLOR_BGR2RGB))
-
         return results
     except Exception as exc:
-        logger.error("Compare procedures failed: %s\n%s", exc, traceback.format_exc())
-        blank = np.zeros((512, 512, 3), dtype=np.uint8)
-        return [blank] * len(PROCEDURES)
+        logger.error("Compare failed: %s\n%s", exc, traceback.format_exc())
+        return [_blank()] * len(PROCEDURES)
 
 
 def intensity_sweep(image_rgb, procedure):
-    """Generate intensity sweep from 0 to 100."""
-    tracker.record("sweep", procedure)
-
+    """Generate results at 0%, 20%, 40%, 60%, 80%, 100% intensity."""
     if image_rgb is None:
         return []
 
     try:
         image_bgr = cv2.cvtColor(np.asarray(image_rgb, dtype=np.uint8), cv2.COLOR_RGB2BGR)
         image_bgr = resize_preserve_aspect(image_bgr, 512)
-
         face = extract_landmarks(image_bgr)
         if face is None:
             return []
 
-        steps = [0, 20, 40, 60, 80, 100]
         results = []
-        for val in steps:
+        for val in [0, 20, 40, 60, 80, 100]:
             if val == 0:
                 results.append((cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB), "0%"))
                 continue
@@ -320,161 +175,49 @@ def intensity_sweep(image_rgb, procedure):
             warped = warp_image_tps(image_bgr, face.pixel_coords, manip.pixel_coords)
             comp = mask_composite(warped, image_bgr, mask)
             results.append((cv2.cvtColor(comp, cv2.COLOR_BGR2RGB), f"{val}%"))
-
         return results
     except Exception as exc:
-        logger.error("Intensity sweep failed: %s\n%s", exc, traceback.format_exc())
+        logger.error("Sweep failed: %s\n%s", exc, traceback.format_exc())
         return []
 
 
-# -- Example images --
-EXAMPLE_DIR = Path(__file__).parent / "examples"
-EXAMPLE_IMAGES = sorted(EXAMPLE_DIR.glob("*.png")) if EXAMPLE_DIR.exists() else []
+# ---------------------------------------------------------------------------
+# Build the Gradio UI
+# ---------------------------------------------------------------------------
 
-# -- Build the procedure table for the description --
-_proc_rows = "\n".join(
-    f"| **{name.replace('_', ' ').title()}** | {desc} |"
-    for name, desc in PROCEDURE_DESCRIPTIONS.items()
+_proc_table = "\n".join(
+    f"| {name.replace('_', ' ').title()} | {desc} |"
+    for name, desc in PROCEDURE_INFO.items()
 )
 
-HEADER_MD = f"""
-# LandmarkDiff
-
-**Anatomically-conditioned facial surgery outcome prediction from standard clinical photography**
-
-Upload a face photo, select a procedure, and adjust intensity to see a predicted
-surgical outcome in real time.
-This demo runs TPS (thin-plate spline) warping on CPU. The full package also supports
-GPU-accelerated ControlNet and img2img inference modes.
-
----
-
-### Supported Procedures
-
-| Procedure | Description |
-|-----------|-------------|
-{_proc_rows}
-
----
-
-### How It Works
-
-1. **Landmark detection** -- MediaPipe extracts a 478-point facial mesh from the input photo.
-2. **Anatomical displacement** -- Procedure-specific presets shift landmark subsets by calibrated
-   vectors (intensity 0-100 controls magnitude).
-3. **TPS deformation** -- A thin-plate spline maps source landmarks to displaced targets, warping
-   the image smoothly while preserving non-surgical regions.
-4. **Masked compositing** -- A procedure-aware mask blends the warped region back into the
-   original, keeping hair, background, and uninvolved anatomy intact.
-
-In GPU modes the deformed wireframe is passed to a ControlNet-conditioned Stable Diffusion
-pipeline for photorealistic rendering, followed by CodeFormer + Real-ESRGAN post-processing.
-
----
-
-[GitHub]({GITHUB_URL}) | \
-[Documentation]({DOCS_URL}) | \
-[Wiki]({WIKI_URL}) | \
-[Discussions]({DISCUSSIONS_URL})
-"""
-
-FOOTER_MD = f"""
----
-<div style="text-align:center; color:#888; font-size:0.85em; padding: 12px 0;">
-  <p>
-    <strong>LandmarkDiff</strong> {VERSION} &middot;
-    TPS warping on CPU &middot;
-    MediaPipe 478-point mesh &middot;
-    6 surgical procedures
-  </p>
-  <p>
-    <a href="{GITHUB_URL}">GitHub</a> &middot;
-    <a href="{DOCS_URL}">Docs</a> &middot;
-    <a href="{WIKI_URL}">Wiki</a> &middot;
-    <a href="{DISCUSSIONS_URL}">Discussions</a> &middot;
-    MIT License
-  </p>
-  <p style="font-size:0.75em; color:#aaa;">
-    Built with Gradio &middot;
-    Powered by MediaPipe + OpenCV &middot;
-    <a href="{GITHUB_URL}/blob/main/CITATION.cff">Cite this work</a>
-  </p>
-</div>
-"""
-
-
 with gr.Blocks(
-    title="LandmarkDiff - Surgical Outcome Prediction",
+    title="LandmarkDiff",
     theme=gr.themes.Soft(),
-    css="""
-    .status-processing {
-        background: linear-gradient(90deg, #e3f2fd 0%, #bbdefb 50%, #e3f2fd 100%);
-        background-size: 200% 100%;
-        animation: shimmer 2s infinite;
-        padding: 8px 16px;
-        border-radius: 6px;
-        text-align: center;
-        font-weight: 500;
-    }
-    @keyframes shimmer {
-        0% { background-position: -200% 0; }
-        100% { background-position: 200% 0; }
-    }
-    .status-ready {
-        background: #e8f5e9;
-        padding: 8px 16px;
-        border-radius: 6px;
-        text-align: center;
-        color: #2e7d32;
-        font-weight: 500;
-    }
-    .status-error {
-        background: #ffebee;
-        padding: 8px 16px;
-        border-radius: 6px;
-        text-align: center;
-        color: #c62828;
-        font-weight: 500;
-    }
-    .proc-detail-box {
-        background: #f5f5f5;
-        border-left: 3px solid #1976d2;
-        padding: 12px 16px;
-        border-radius: 4px;
-        margin-top: 8px;
-    }
-    """,
 ) as demo:
-    gr.Markdown(HEADER_MD)
-
-    # -- Single Procedure tab --
+    gr.Markdown(
+        f"# LandmarkDiff\n\n"
+        f"Facial surgery outcome prediction from clinical photography. "
+        f"Upload a face photo, pick a procedure, adjust intensity.\n\n"
+        f"| Procedure | Effect |\n|---|---|\n{_proc_table}\n\n"
+        f"[GitHub]({GITHUB_URL}) | "
+        f"[Docs]({GITHUB_URL}/tree/main/docs) | "
+        f"[Wiki]({GITHUB_URL}/wiki)"
+    )
+
+    # -- Tab 1: Single Procedure --
     with gr.Tab("Single Procedure"):
         with gr.Row():
             with gr.Column(scale=1):
-                input_image = gr.Image(label="Upload Face Photo", type="numpy", height=350)
+                input_image = gr.Image(label="Face Photo", type="numpy", height=350)
                 procedure = gr.Radio(
-                    choices=PROCEDURES,
-                    value="rhinoplasty",
-                    label="Surgical Procedure",
-                )
-                proc_detail = gr.Markdown(
-                    value=_get_procedure_description("rhinoplasty"),
-                    elem_classes=["proc-detail-box"],
+                    choices=PROCEDURES, value="rhinoplasty", label="Procedure",
                 )
                 intensity = gr.Slider(
-                    minimum=0,
-                    maximum=100,
-                    value=50,
-                    step=1,
-                    label="Intensity (%)",
-                    info="0 = no change, 100 = maximum effect",
-                )
-                run_btn = gr.Button("Generate Preview", variant="primary", size="lg")
-                status_box = gr.HTML(
-                    value='<div class="status-ready">Ready -- upload a photo or click an example below</div>',
-                    label="Status",
+                    0, 100, 50, step=1, label="Intensity (%)",
+                    info="0 = no change, 100 = maximum",
                 )
-                info_box = gr.Textbox(label="Info", lines=7, interactive=False)
+                run_btn = gr.Button("Generate", variant="primary", size="lg")
+                info_box = gr.Textbox(label="Info", lines=6, interactive=False)
 
             with gr.Column(scale=2):
                 with gr.Row():
@@ -482,157 +225,74 @@ with gr.Blocks(
                     out_mask = gr.Image(label="Surgical Mask", height=256)
                 with gr.Row():
                     out_result = gr.Image(label="Predicted Result", height=256)
-                    out_sidebyside = gr.Image(label="Original", height=256)
+                    out_original = gr.Image(label="Original", height=256)
 
-        # -- Example images --
         if EXAMPLE_IMAGES:
-            gr.Markdown("### Try an Example")
             gr.Examples(
                 examples=[[str(p)] for p in EXAMPLE_IMAGES],
                 inputs=[input_image],
-                label="Click an example face to load it (these are synthetic sketches "
-                      "-- for best results, upload a real photo)",
+                label="Example faces (click to load)",
             )
 
-        # -- Procedure description update --
-        procedure.change(
-            fn=_get_procedure_description,
-            inputs=[procedure],
-            outputs=[proc_detail],
-        )
-
-        # -- Processing with status indicator --
-        def _process_with_status(image_rgb, proc, intens):
-            results = process_image(image_rgb, proc, intens)
-            # Last element is the info/error text
-            info_text = results[-1]
-            if "error" in info_text.lower() or "No face" in info_text:
-                status_html = f'<div class="status-error">{info_text.split(chr(10))[0]}</div>'
-            else:
-                status_html = '<div class="status-ready">Done -- result ready</div>'
-            return results + (status_html,)
-
-        all_outputs = [out_wireframe, out_mask, out_result, out_sidebyside, info_box, status_box]
-
-        run_btn.click(
-            fn=lambda: '<div class="status-processing">Processing... extracting landmarks and warping</div>',
-            inputs=None,
-            outputs=[status_box],
-        ).then(
-            fn=_process_with_status,
-            inputs=[input_image, procedure, intensity],
-            outputs=all_outputs,
-        )
-
-        # Auto-trigger on input change (image upload, procedure change, intensity change)
+        outputs = [out_wireframe, out_mask, out_result, out_original, info_box]
+        run_btn.click(fn=process_image, inputs=[input_image, procedure, intensity], outputs=outputs)
         for trigger in [input_image, procedure, intensity]:
-            trigger.change(
-                fn=lambda: '<div class="status-processing">Processing...</div>',
-                inputs=None,
-                outputs=[status_box],
-            ).then(
-                fn=_process_with_status,
-                inputs=[input_image, procedure, intensity],
-                outputs=all_outputs,
-            )
+            trigger.change(fn=process_image, inputs=[input_image, procedure, intensity], outputs=outputs)
 
-    # -- Compare Procedures tab --
-    with gr.Tab("Compare Procedures"):
-        gr.Markdown("Compare all six procedures side by side at the same intensity.")
+    # -- Tab 2: Compare Procedures --
+    with gr.Tab("Compare All"):
+        gr.Markdown("All six procedures at the same intensity, side by side.")
         with gr.Row():
             with gr.Column(scale=1):
-                cmp_image = gr.Image(label="Upload Face Photo", type="numpy", height=300)
+                cmp_image = gr.Image(label="Face Photo", type="numpy", height=300)
                 cmp_intensity = gr.Slider(0, 100, 50, step=1, label="Intensity (%)")
-                cmp_btn = gr.Button("Compare All", variant="primary", size="lg")
-                cmp_status = gr.HTML(
-                    value='<div class="status-ready">Ready</div>',
-                )
+                cmp_btn = gr.Button("Compare", variant="primary", size="lg")
             with gr.Column(scale=2):
                 cmp_outputs = []
-                rows_needed = (len(PROCEDURES) + 2) // 3
-                for row_idx in range(rows_needed):
+                for row_idx in range(2):
                     with gr.Row():
                         for col_idx in range(3):
-                            proc_idx = row_idx * 3 + col_idx
-                            if proc_idx < len(PROCEDURES):
+                            idx = row_idx * 3 + col_idx
+                            if idx < len(PROCEDURES):
                                 cmp_outputs.append(
                                     gr.Image(
-                                        label=PROCEDURES[proc_idx].replace("_", " ").title(),
+                                        label=PROCEDURES[idx].replace("_", " ").title(),
                                         height=200,
                                     )
                                 )
 
-        # Example images for Compare tab
         if EXAMPLE_IMAGES:
             gr.Examples(
                 examples=[[str(p)] for p in EXAMPLE_IMAGES],
-                inputs=[cmp_image],
-                label="Example faces",
+                inputs=[cmp_image], label="Examples",
             )
 
-        def _compare_with_status(img, intens):
-            results = compare_procedures(img, intens)
-            return results + ['<div class="status-ready">Done -- 6 procedures compared</div>']
-
-        cmp_btn.click(
-            fn=lambda: '<div class="status-processing">Processing 6 procedures...</div>',
-            inputs=None,
-            outputs=[cmp_status],
-        ).then(
-            fn=_compare_with_status,
-            inputs=[cmp_image, cmp_intensity],
-            outputs=cmp_outputs + [cmp_status],
-        )
+        cmp_btn.click(fn=compare_procedures, inputs=[cmp_image, cmp_intensity], outputs=cmp_outputs)
 
-    # -- Intensity Sweep tab --
+    # -- Tab 3: Intensity Sweep --
     with gr.Tab("Intensity Sweep"):
-        gr.Markdown(
-            "See how a procedure looks across intensity levels (0% through 100% in 20% steps)."
-        )
+        gr.Markdown("See a procedure at 0% through 100% in six steps.")
         with gr.Row():
             with gr.Column(scale=1):
-                sweep_image = gr.Image(label="Upload Face Photo", type="numpy", height=300)
-                sweep_procedure = gr.Radio(
-                    choices=PROCEDURES,
-                    value="rhinoplasty",
-                    label="Procedure",
-                )
-                sweep_btn = gr.Button("Generate Sweep", variant="primary", size="lg")
-                sweep_status = gr.HTML(
-                    value='<div class="status-ready">Ready</div>',
-                )
+                sweep_image = gr.Image(label="Face Photo", type="numpy", height=300)
+                sweep_proc = gr.Radio(choices=PROCEDURES, value="rhinoplasty", label="Procedure")
+                sweep_btn = gr.Button("Sweep", variant="primary", size="lg")
             with gr.Column(scale=2):
-                sweep_gallery = gr.Gallery(
-                    label="Intensity Sweep (0% - 100%)", columns=3, height=400
-                )
+                sweep_gallery = gr.Gallery(label="0% to 100%", columns=3, height=400)
 
-        # Example images for Sweep tab
         if EXAMPLE_IMAGES:
             gr.Examples(
                 examples=[[str(p)] for p in EXAMPLE_IMAGES],
-                inputs=[sweep_image],
-                label="Example faces",
+                inputs=[sweep_image], label="Examples",
             )
 
-        def _sweep_with_status(img, proc):
-            results = intensity_sweep(img, proc)
-            if results:
-                status = '<div class="status-ready">Done -- 6 intensity levels generated</div>'
-            else:
-                status = '<div class="status-error">No face detected or processing failed</div>'
-            return results, status
-
-        sweep_btn.click(
-            fn=lambda: '<div class="status-processing">Generating 6 intensity levels...</div>',
-            inputs=None,
-            outputs=[sweep_status],
-        ).then(
-            fn=_sweep_with_status,
-            inputs=[sweep_image, sweep_procedure],
-            outputs=[sweep_gallery, sweep_status],
-        )
+        sweep_btn.click(fn=intensity_sweep, inputs=[sweep_image, sweep_proc], outputs=[sweep_gallery])
 
-    gr.Markdown(FOOTER_MD)
+    gr.Markdown(
+        f"<div style='text-align:center;color:#999;font-size:0.8em;padding:8px'>"
+        f"LandmarkDiff v0.2.2 | TPS on CPU | MediaPipe 478-point mesh | "
+        f"<a href='{GITHUB_URL}'>GitHub</a> | MIT License</div>"
+    )
 
 if __name__ == "__main__":
     demo.launch(show_error=True)