Upload 3 files

README.md

@@ -1,13 +1,36 @@
----
-title: GazeAlign
-emoji: 📊
-colorFrom: pink
-colorTo: gray
-sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.13'
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: GazeAlign
+emoji: 👁️
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: "4.44.0"
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# GazeAlign
+
+Gaze-supervised medical image classification.
+
+**How to use**
+
+1. **Upload an image** — JPG / PNG / BMP / TIFF / WEBP or a **DICOM** (`.dcm`).
+2. **Add fixations** (a radiologist-style scanpath) in either of two ways:
+   - **Click** on the image to drop fixation points, or
+   - **Upload a fixation table** (`.csv` / `.xlsx` / `.xls`) and map its
+     `ID / X / Y / Time` columns — X/Y may be raw pixels or normalised `[0,1]`.
+3. **Run** to get the **predicted class** with per-class probabilities,
+   plus the learned gaze-conditioned attention mask/overlay.
+
+**Model weights**
+
+The demo loads the checkpoint declared by the `cxr` preset in
+`configs/presets.yaml` (default `checkpoints/best_model_CXR.pth`). The
+weights are not committed to the GitHub repo (too large); add them to this
+Space — e.g. track `checkpoints/*.pth` with Git LFS, or download them in a
+startup step — so `checkpoints/best_model_CXR.pth` exists at launch.
+
+See the [GitHub repository](https://github.com/MohammedOussamaBEN/GazeAlign)
+for training code, evaluation scripts, and the paper.

app.py

@@ -0,0 +1,608 @@
+"""
+Gradio demo for GazeAlign — gaze-supervised medical image classification.
+
+Workflow
+--------
+1. Upload an image (JPG / PNG / BMP / TIFF / WEBP / DICOM).
+2. Provide a radiologist-style scanpath in **either** of two ways:
+     • click on the image to drop fixation points, or
+     • upload a fixation table (.csv / .xlsx / .xls) and map its columns.
+3. Run the model to get the predicted class (+ per-class probabilities)
+   and the learned gaze-conditioned attention mask.
+
+Run locally with:  python app.py
+Deployed as a HuggingFace Space, this file is the entry point.
+"""
+
+from __future__ import annotations
+
+import sys
+import types
+import os
+from pathlib import Path
+
+# ── 1. audioop shim (Python 3.13 removed audioop; some deps import it) ────────
+if sys.version_info >= (3, 13):
+    for _mod in ("audioop", "pyaudioop"):
+        if _mod not in sys.modules:
+            sys.modules[_mod] = types.ModuleType(_mod)
+
+# ── 2. Patch starlette Jinja2Templates.TemplateResponse (old/new signature) ──
+import starlette.templating as _st
+
+_orig_TR = _st.Jinja2Templates.TemplateResponse
+
+
+def _compat_TR(self, *args, **kwargs):
+    if args and isinstance(args[0], str) and len(args) >= 2 and isinstance(args[1], dict):
+        name = args[0]
+        context = args[1]
+        status_code = args[2] if len(args) > 2 else kwargs.get("status_code", 200)
+        headers = kwargs.get("headers")
+        media_type = kwargs.get("media_type")
+        background = kwargs.get("background")
+        template = self.get_template(name)
+        return _st._TemplateResponse(
+            template, context,
+            status_code=status_code,
+            headers=headers,
+            media_type=media_type,
+            background=background,
+        )
+    return _orig_TR(self, *args, **kwargs)
+
+
+_st.Jinja2Templates.TemplateResponse = _compat_TR  # type: ignore[method-assign]
+
+import gradio as gr
+
+# ── 3. gradio_client schema shim (guards against bad additionalProperties) ───
+try:
+    import gradio_client.utils as _gcu
+
+    _orig_inner = _gcu._json_schema_to_python_type
+
+    def _safe_inner(schema, defs=None):
+        if not isinstance(schema, dict):
+            return "Any"
+        if not isinstance(schema.get("additionalProperties"), dict):
+            schema = {k: v for k, v in schema.items() if k != "additionalProperties"}
+        return _orig_inner(schema, defs)
+
+    _gcu._json_schema_to_python_type = _safe_inner
+except Exception:
+    pass
+
+# ── 4. huggingface_hub HfFolder shim (removed in newer versions) ─────────────
+try:
+    from huggingface_hub import HfFolder  # noqa: F401
+except ImportError:
+    import huggingface_hub as _hfh
+
+    class _FakeHfFolder:
+        @staticmethod
+        def get_token():
+            return None
+
+    _hfh.HfFolder = _FakeHfFolder  # type: ignore[attr-defined]
+    sys.modules["huggingface_hub"].HfFolder = _FakeHfFolder  # type: ignore[assignment]
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image, ImageDraw
+
+# ── 5. Path setup — make the repo root importable ────────────────────────────
+_here = Path(__file__).resolve().parent
+for _candidate in [_here] + list(_here.parents):
+    _s = str(_candidate)
+    if _s not in sys.path:
+        sys.path.insert(0, _s)
+
+from GazeAlign import get_device, get_scanpath  # noqa: E402
+from GazeAlign.visualize import heatmap_to_image, make_overlay, patch_to_image  # noqa: E402
+from scripts.predict_single import GazeAlignPredictor  # noqa: E402
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Config
+# ─────────────────────────────────────────────────────────────────────────────
+
+PRESETS_PATH = os.path.join(os.path.dirname(__file__), "..", "configs", "presets.yaml")
+# Friendly label → preset key in configs/presets.yaml. Add rows here as you
+# train GazeAlign on new modalities.
+PRESETS = {
+    "Chest X-ray — CHF / Normal / Pneumonia": "cxr",
+}
+POINT_COLORS = ["#ff3b30", "#ff9500", "#ffcc00", "#34c759", "#5ac8fa", "#007aff", "#af52de"]
+_NO_COL = "— none —"
+
+_UPLOAD_LABEL = "Drop / click to load  .jpg  .png  .bmp  .tif  .tiff  .webp  .dcm"
+_FIXATION_LABEL = "Click to place fixations"
+_FIXFILE_LABEL = "Upload fixation file (.csv / .xlsx / .xls) — optional"
+
+_DEVICE = get_device()
+_PREDICTORS: dict[str, GazeAlignPredictor] = {}
+
+
+def get_predictor(preset_key: str) -> GazeAlignPredictor:
+    """Lazily build & cache one predictor per preset."""
+    if preset_key not in _PREDICTORS:
+        _PREDICTORS[preset_key] = GazeAlignPredictor.from_preset(
+            preset_key, presets_path=PRESETS_PATH, device=str(_DEVICE)
+        )
+    return _PREDICTORS[preset_key]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def dcm_to_pil(dcm_path: str) -> Image.Image:
+    """Load a DICOM file and return an RGB PIL image."""
+    import pydicom
+
+    dcm = pydicom.dcmread(dcm_path)
+    arr = dcm.pixel_array.astype(np.float32)
+    arr = arr - arr.min()
+    arr = arr / (arr.max() + 1e-8)
+    arr = (arr * 255).astype(np.uint8)
+    if arr.ndim == 2:
+        return Image.fromarray(arr, mode="L").convert("RGB")
+    if arr.ndim == 3 and arr.shape[0] in (1, 3, 4):  # (C, H, W) → (H, W, C)
+        arr = arr.transpose(1, 2, 0)
+    return Image.fromarray(arr).convert("RGB")
+
+
+def draw_points(image: Image.Image, points: list) -> Image.Image:
+    """Overlay fixation circles + connecting saccades on a copy of `image`.
+
+    `points`: list of (x_px, y_px, weight) in original-image pixel coords,
+    `weight` in [0, 1] (relative dwell / recency, controls circle size).
+    """
+    if image is None:
+        return None
+    vis = image.convert("RGB").copy()
+    draw = ImageDraw.Draw(vis)
+    w, h = vis.size
+    r = max(6, min(w, h) // 80)
+    prev = None
+    for (x_px, y_px, _weight) in points:
+        color = POINT_COLORS[0]
+        if prev is not None:
+            draw.line([prev, (x_px, y_px)], fill=color, width=2)
+        prev = (x_px, y_px)
+    for i, (x_px, y_px, weight) in enumerate(points):
+        color = POINT_COLORS[i % len(POINT_COLORS)]
+        rad = r * (0.6 + 0.8 * float(weight))
+        draw.ellipse(
+            [x_px - rad, y_px - rad, x_px + rad, y_px + rad],
+            outline=color, width=3,
+        )
+        draw.text((x_px + rad + 2, y_px - rad), str(i + 1), fill=color)
+    return vis
+
+
+def read_table(path: str) -> pd.DataFrame:
+    """Load a .csv / .xlsx / .xls fixation file into a DataFrame."""
+    ext = Path(path).suffix.lower()
+    if ext in (".xlsx", ".xls"):
+        return pd.read_excel(path)
+    # Sniff delimiter — eye-tracker exports are sometimes tab-separated
+    # even with a .csv extension.
+    return pd.read_csv(path, sep=None, engine="python")
+
+
+def normalize_xy(x_vals: np.ndarray, y_vals: np.ndarray, img_w: int, img_h: int):
+    """Convert X/Y column values to pixel coords for the given image size.
+
+    Values already in [0, 1] (with rounding slack) are treated as
+    normalised; otherwise they are assumed to be raw pixels and clamped to
+    the image bounds.
+    """
+    looks_normalized = (
+        np.nanmax(x_vals) <= 1.05 and np.nanmax(y_vals) <= 1.05
+        and np.nanmin(x_vals) >= -0.05 and np.nanmin(y_vals) >= -0.05
+    )
+    if looks_normalized:
+        x_px = np.clip(x_vals, 0, 1) * img_w
+        y_px = np.clip(y_vals, 0, 1) * img_h
+    else:
+        x_px = np.clip(x_vals, 0, img_w)
+        y_px = np.clip(y_vals, 0, img_h)
+    return x_px, y_px
+
+
+def _resolve_path(file_obj):
+    """Extract a filesystem path from whatever gr.File passes."""
+    if isinstance(file_obj, str):
+        return file_obj
+    if isinstance(file_obj, dict):
+        return file_obj.get("name") or file_obj.get("path") or file_obj.get("tmp_path") or ""
+    if hasattr(file_obj, "name"):
+        return file_obj.name
+    return ""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Event handlers — image
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def on_file_upload(file_obj):
+    """Load any image or DICOM and switch the panel to fixation-click mode."""
+    _no_change = (None, [], "", gr.update(), gr.update(), gr.update())
+    if file_obj is None:
+        return _no_change
+
+    path = _resolve_path(file_obj)
+    if not path:
+        gr.Warning("Could not resolve file path.")
+        return _no_change
+
+    image_name = Path(path).name
+    ext = Path(path).suffix.lower()
+    try:
+        pil = dcm_to_pil(path) if ext == ".dcm" else Image.open(path).convert("RGB")
+    except Exception as e:  # noqa: BLE001
+        gr.Warning(f"Could not load file: {e}")
+        return _no_change
+
+    return (
+        pil,                                                        # orig_image_state
+        [],                                                         # points_state
+        image_name,                                                 # image_name_state
+        gr.update(visible=False),                                   # upload_zone → hide
+        gr.update(value=pil, visible=True, label=_FIXATION_LABEL),  # image_panel → show
+        gr.update(visible=True),                                    # delete_btn → show
+    )
+
+
+def on_select(orig_image: Image.Image, points: list, weight: float, evt: gr.SelectData):
+    """Record a fixation click in original-image pixel coords."""
+    if orig_image is None:
+        gr.Warning("Upload an image first.")
+        return points, gr.update()
+    x_px, y_px = float(evt.index[0]), float(evt.index[1])
+    new_points = points + [(x_px, y_px, float(weight))]
+    return new_points, draw_points(orig_image, new_points)
+
+
+def on_clear(orig_image):
+    """Remove all fixations but keep the current image."""
+    if orig_image is None:
+        return [], gr.update()
+    return [], gr.update(value=orig_image)
+
+
+def on_delete():
+    """Delete the current image and return to upload mode."""
+    return (
+        None,                                    # orig_image_state
+        [],                                      # points_state
+        "",                                      # image_name_state
+        gr.update(value=None, visible=True),     # upload_zone → show (reset)
+        gr.update(value=None, visible=False),    # image_panel → hide
+        gr.update(visible=False),                # delete_btn → hide
+    )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Event handlers — fixation file
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def on_fixfile_upload(file_obj):
+    """Load the fixation table and populate the column-mapping dropdowns."""
+    _hide = (
+        None, gr.update(visible=False),
+        gr.update(choices=[], value=None), gr.update(choices=[], value=None),
+        gr.update(choices=[], value=None), gr.update(choices=[], value=None),
+        gr.update(visible=False),
+    )
+    if file_obj is None:
+        return _hide
+
+    path = _resolve_path(file_obj)
+    if not path:
+        gr.Warning("Could not resolve fixation file path.")
+        return _hide
+
+    try:
+        df = read_table(path)
+    except Exception as e:  # noqa: BLE001
+        gr.Warning(f"Could not read fixation file: {e}")
+        return _hide
+
+    if df.empty or len(df.columns) == 0:
+        gr.Warning("Fixation file appears to be empty.")
+        return _hide
+
+    cols = [str(c) for c in df.columns]
+
+    def _guess(*keywords, fallback=None):
+        # Priority-ordered: try each keyword across ALL columns before moving
+        # to the next, so e.g. "dicom" wins over a stray "id" in "SESSION_ID".
+        for k in keywords:
+            for c in cols:
+                if k in c.lower():
+                    return c
+        return fallback if fallback is not None else cols[0]
+
+    guess_id = _guess("dicom", "image", "id", "name", "file", fallback=cols[0])
+    guess_x = _guess("x_original", "x_orig", "fix_x", "pos_x", "gaze_x", "x_pixel", fallback=None)
+    if guess_x is None:
+        guess_x = next(
+            (c for c in cols if c.lower().rstrip("_").endswith("x") and "index" not in c.lower()),
+            cols[0],
+        )
+    guess_y = _guess("y_original", "y_orig", "fix_y", "pos_y", "gaze_y", "y_pixel", fallback=None)
+    if guess_y is None:
+        guess_y = next(
+            (c for c in cols if c.lower().rstrip("_").endswith("y") and "index" not in c.lower()),
+            cols[0],
+        )
+
+    time_choices = [_NO_COL] + cols
+    guess_time = _guess("time", "secs", "duration", "dur", "timestamp", fallback=_NO_COL)
+
+    return (
+        df.to_json(),                                       # fixfile_df_state
+        gr.update(visible=True),                            # mapping_row → show
+        gr.update(choices=cols, value=guess_id),            # id_col_dd
+        gr.update(choices=cols, value=guess_x),             # x_col_dd
+        gr.update(choices=cols, value=guess_y),             # y_col_dd
+        gr.update(choices=time_choices, value=guess_time),  # time_col_dd
+        gr.update(visible=True),                            # apply_fix_btn → show
+    )
+
+
+def on_apply_fixfile(fixfile_json, id_col, x_col, y_col, time_col, orig_image, image_name):
+    """Match rows to the loaded image (by filename) and load them as
+    fixation points, replacing whatever points are currently set.
+
+    If rows can't be matched by filename but the file holds a single image's
+    worth of fixations, all rows are used (handy for single-image CSVs whose
+    ID column doesn't match the uploaded filename)."""
+    if orig_image is None:
+        gr.Warning("Load an image first, then apply the fixation file.")
+        return gr.update(), gr.update()
+    if not fixfile_json:
+        gr.Warning("Upload a fixation file first.")
+        return gr.update(), gr.update()
+    if not x_col or not y_col:
+        gr.Warning("Pick the X and Y columns first.")
+        return gr.update(), gr.update()
+
+    df = pd.read_json(fixfile_json)
+
+    sub = df
+    if id_col and image_name:
+        mask = df[id_col].astype(str) == image_name
+        if not mask.any():
+            stem = Path(image_name).stem
+            mask = df[id_col].astype(str).apply(lambda v: Path(str(v)).stem) == stem
+        if mask.any():
+            sub = df[mask]
+        elif df[id_col].nunique() > 1:
+            gr.Warning(
+                f"No rows match the loaded image ('{image_name}') and the file "
+                f"has several ids — using ALL rows. Check the ID column."
+            )
+
+    if sub.empty:
+        gr.Warning("No usable fixation rows found.")
+        return gr.update(), gr.update()
+
+    w, h = orig_image.size
+    x_vals = sub[x_col].astype(float).to_numpy()
+    y_vals = sub[y_col].astype(float).to_numpy()
+    x_px, y_px = normalize_xy(x_vals, y_vals, w, h)
+
+    if time_col and time_col != _NO_COL and time_col in sub.columns:
+        t_raw = sub[time_col].astype(float).to_numpy()
+        order = np.argsort(t_raw)  # chronological order
+        x_px, y_px, t_raw = x_px[order], y_px[order], t_raw[order]
+        tmin, tmax = float(np.nanmin(t_raw)), float(np.nanmax(t_raw))
+        weight = (t_raw - tmin) / (tmax - tmin + 1e-8)
+    else:
+        weight = np.linspace(0.0, 1.0, len(sub))
+
+    new_points = [(float(xp), float(yp), float(wt)) for xp, yp, wt in zip(x_px, y_px, weight)]
+    return new_points, draw_points(orig_image, new_points)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Inference
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def run(orig_image: Image.Image, points: list, preset_name: str):
+    import traceback
+
+    if orig_image is None:
+        gr.Warning("Upload an image first.")
+        return None, "", None, None
+    if not points or len(points) < 2:
+        gr.Warning("Provide at least 2 fixations (click the image or load a fixation file).")
+        return None, "", None, None
+
+    preset_key = PRESETS[preset_name]
+    try:
+        predictor = get_predictor(preset_key)
+    except FileNotFoundError as e:
+        gr.Warning(str(e))
+        return None, f"**Checkpoint not found** for preset `{preset_key}`.", None, None
+    except Exception as e:  # noqa: BLE001
+        traceback.print_exc()
+        gr.Warning(f"Could not load model: {e}")
+        return None, "", None, None
+
+    w, h = orig_image.size
+    # Build a MIMIC-style scanpath dataframe. The 3rd component (weight)
+    # drives a monotonically increasing time axis for the scanpath encoder.
+    weights = np.asarray([p[2] for p in points], dtype=float)
+    times = np.cumsum(np.clip(weights, 1e-3, None))
+    df = pd.DataFrame(
+        {
+            "DICOM_ID": ["webdemo"] * len(points),
+            "X_ORIGINAL": [p[0] for p in points],
+            "Y_ORIGINAL": [p[1] for p in points],
+            "Time (in secs)": times,
+        }
+    )
+
+    scanpath = get_scanpath(df, "webdemo", img_height=h, img_width=w)
+    if scanpath is None or scanpath.numel() == 0:
+        gr.Warning("Could not build a scanpath from the fixations.")
+        return None, "", None, None
+    scanpath = scanpath[:200].to(predictor.device)
+
+    img_tensor = predictor.transform(np.array(orig_image)).unsqueeze(0).to(predictor.device)
+    try:
+        with torch.no_grad():
+            _, patch_tokens, _ = predictor.image_encoder(img_tensor)
+            _, sp_emb, _ = predictor.scanpath_encoder([scanpath])
+            patch_mask = torch.sigmoid(predictor.mask_generator(sp_emb))  # [1, g, g]
+
+            B, N, D = patch_tokens.shape
+            feat_attended = (patch_tokens * patch_mask.view(B, N, 1)).mean(dim=1)
+            logits = predictor.classifier(feat_attended)
+            probs = torch.softmax(logits, dim=1)[0].cpu().numpy()
+    except Exception as e:  # noqa: BLE001
+        traceback.print_exc()
+        gr.Warning(f"Prediction failed: {e}")
+        return None, "", None, None
+
+    class_probs = {c: float(p) for c, p in zip(predictor.classes, probs)}
+    predicted_class = max(class_probs, key=class_probs.get)
+
+    # Learned gaze-conditioned attention mask, upsampled + overlaid.
+    img_size = predictor.img_size
+    mask_full = patch_to_image(patch_mask[0].cpu().numpy(), img_size, img_size)
+    display_img = np.array(orig_image.resize((img_size, img_size)))
+    overlay = make_overlay(display_img, mask_full)
+    mask_img = heatmap_to_image(mask_full)
+
+    prob_lines = "\n".join(
+        f"- **{c}**: {p:.3f}" for c, p in sorted(class_probs.items(), key=lambda kv: -kv[1])
+    )
+    summary = f"### Predicted: **{predicted_class}**\n\n{prob_lines}"
+
+    return class_probs, summary, overlay, mask_img
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# UI
+# ─────────────────────────────────────────────────────────────────────────────
+
+_CSS = """
+#run-btn {font-weight: 600;}
+.footer-note {opacity: 0.7; font-size: 0.85rem;}
+"""
+
+with gr.Blocks(title="GazeAlign", css=_CSS) as demo:
+    gr.Markdown(
+        """
+        # 👁️ GazeAlign — Gaze-Supervised Medical Image Classification
+
+        **1.** Upload an image · **2.** Add fixations by *clicking* the image
+        **or** *uploading a fixation table (.csv / .xlsx)* · **3.** Run the model.
+        """
+    )
+
+    orig_image_state = gr.State(None)
+    points_state = gr.State([])
+    image_name_state = gr.State("")
+    fixfile_df_state = gr.State(None)
+
+    with gr.Row():
+        # ── Left: image + fixations ──────────────────────────────────────────
+        with gr.Column(scale=1):
+            preset_dd = gr.Dropdown(
+                choices=list(PRESETS.keys()),
+                value=list(PRESETS.keys())[0],
+                label="Model / modality preset",
+            )
+
+            upload_zone = gr.File(
+                label=_UPLOAD_LABEL,
+                file_types=[".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff", ".webp", ".dcm"],
+                type="filepath",
+            )
+            image_panel = gr.Image(
+                label=_FIXATION_LABEL, type="pil", interactive=True, visible=False
+            )
+
+            weight_slider = gr.Slider(
+                0.0, 1.0, value=0.5, step=0.05,
+                label="Fixation weight (dwell) for clicks",
+            )
+            with gr.Row():
+                clear_btn = gr.Button("Clear fixations")
+                delete_btn = gr.Button("Delete image", visible=False)
+
+            gr.Markdown("**— or —** load fixations from a file:")
+            fixfile = gr.File(
+                label=_FIXFILE_LABEL, file_types=[".csv", ".xlsx", ".xls"], type="filepath"
+            )
+            with gr.Row(visible=False) as mapping_row:
+                id_col_dd = gr.Dropdown(label="ID column", choices=[])
+                x_col_dd = gr.Dropdown(label="X column", choices=[])
+                y_col_dd = gr.Dropdown(label="Y column", choices=[])
+                time_col_dd = gr.Dropdown(label="Time column (optional)", choices=[])
+            apply_fix_btn = gr.Button("Apply fixation file", visible=False)
+
+        # ── Right: results ───────────────────────────────────────────────────
+        with gr.Column(scale=1):
+            run_btn = gr.Button("Run GazeAlign", variant="primary", elem_id="run-btn")
+            label_output = gr.Label(label="Predicted class (probabilities)", num_top_classes=5)
+            summary_output = gr.Markdown()
+            overlay_output = gr.Image(label="Gaze-conditioned attention overlay")
+            mask_output = gr.Image(label="Learned attention mask")
+
+    gr.Markdown(
+        "<div class='footer-note'>Fixation tables use raw pixel or normalised "
+        "[0,1] X/Y coordinates. See the "
+        "<a href='https://github.com/MohammedOussamaBEN/GazeAlign'>GitHub repo</a> "
+        "for training and evaluation code.</div>"
+    )
+
+    # ── wiring ──
+    upload_zone.upload(
+        on_file_upload,
+        [upload_zone],
+        [orig_image_state, points_state, image_name_state, upload_zone, image_panel, delete_btn],
+    )
+    image_panel.select(
+        on_select,
+        [orig_image_state, points_state, weight_slider],
+        [points_state, image_panel],
+    )
+    clear_btn.click(on_clear, [orig_image_state], [points_state, image_panel])
+    delete_btn.click(
+        on_delete,
+        None,
+        [orig_image_state, points_state, image_name_state, upload_zone, image_panel, delete_btn],
+    )
+
+    fixfile.upload(
+        on_fixfile_upload,
+        [fixfile],
+        [fixfile_df_state, mapping_row, id_col_dd, x_col_dd, y_col_dd, time_col_dd, apply_fix_btn],
+    )
+    apply_fix_btn.click(
+        on_apply_fixfile,
+        [fixfile_df_state, id_col_dd, x_col_dd, y_col_dd, time_col_dd, orig_image_state, image_name_state],
+        [points_state, image_panel],
+    )
+
+    run_btn.click(
+        run,
+        [orig_image_state, points_state, preset_dd],
+        [label_output, summary_output, overlay_output, mask_output],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,14 @@
+torch>=2.1
+torchvision>=0.16
+timm>=1.0
+transformers>=4.40
+opencv-python-headless>=4.8
+numpy>=1.24
+pandas>=2.0
+scipy>=1.10
+scikit-learn>=1.3
+pyyaml>=6.0
+pillow>=10.0
+gradio>=4.0
+pydicom>=2.4
+openpyxl>=3.1