Deploy Project Halide Gradio Space

README.md

@@ -35,9 +35,10 @@ Project Halide is an edge-native diagnostic workbench for analog film scans by
 
 The runtime uses MiniCPM-V 4.6 for defect extraction and
 Nemotron-Mini-4B-Instruct for diagnostic reasoning. The vision pass combines
-full-frame inspection with a tiled fallback for large scans where crack
-networks are too small in the global image. Model inference runs on the Space
-GPU runtime without cloud inference APIs.
+full-frame inspection, tiled fallback for large scans, a conservative
+image-analysis validator for obvious scratches, and geometric filtering for
+sprocket or frame-edge artifacts. Model inference runs on the Space GPU runtime
+without cloud inference APIs.
 
 Fine-tuned vision model:
 <https://huggingface.co/Lonelyguyse1/halide-vision>
@@ -55,6 +56,41 @@ Modal was used for offline training, held-out GPU evaluation, checkpoint upload,
 GGUF conversion, and Space deployment. The runtime app itself does not call
 Modal or any hosted inference API.
 
+## How It Works
+
+1. Upload a film scan, negative photo, or contact-sheet crop.
+2. MiniCPM-V 4.6 extracts candidate defects as structured JSON.
+3. The validator normalizes boxes, filters bad geometry, removes duplicate or
+   sprocket-like edge artifacts, and adds high-precision scratch candidates
+   when clear linear evidence is visible.
+4. Nemotron-Mini-4B-Instruct reads the validated evidence plus user metadata and
+   writes a lab-style diagnosis with physical fixes.
+5. SQLite stores local diagnostic history so earlier runs can be reopened.
+
+## Sponsor Usage
+
+- OpenBMB: MiniCPM-V 4.6 is the primary vision model, fine-tuned for film defect
+  extraction and published at `Lonelyguyse1/halide-vision`.
+- NVIDIA: Nemotron-Mini-4B-Instruct produces the diagnostic report and keeps
+  uncertain film metadata lower priority than visible evidence.
+- Modal: used offline for training, evaluation, checkpoint export, GGUF
+  conversion, model upload, and Space deployment support.
+- OpenAI Codex: used for implementation, testing, documentation, and
+  source-control commits in the linked GitHub repository.
+
+## Field Guide Alignment
+
+- Gradio Space under the official `build-small-hackathon` organization.
+- All runtime inference uses open weights on the Space GPU, with no hosted model
+  API calls.
+- Model sizes stay under the 32B limit, with MiniCPM-V 4.6 at 1.3B parameters
+  and Nemotron-Mini-4B-Instruct at 4B parameters.
+- Custom autumn-themed UI with a purpose-built compare viewer and diagnostic
+  history.
+- Fine-tuned vision model and GGUF artifact are published on the author's
+  Hugging Face profile.
+- Demo video, public launch post, and field notes are linked from this Space.
+
 Held-out validation summary:
 
 - Four visibly damaged private negatives were detected with scratch and

config.py

@@ -69,6 +69,8 @@ class VisionConfig:
     tile_max_side: int
     tile_overlap: float
     tile_max_tiles: int
+    classical_assist_enabled: bool
+    classical_assist_max_defects: int
 
 
 @dataclass(frozen=True)
@@ -109,6 +111,8 @@ def get_vision_config() -> VisionConfig:
         tile_max_side=env_int("HALIDE_TILE_MAX_SIDE", 960),
         tile_overlap=env_float("HALIDE_TILE_OVERLAP", 0.35),
         tile_max_tiles=env_int("HALIDE_TILE_MAX_TILES", 9),
+        classical_assist_enabled=env_bool("HALIDE_ENABLE_CLASSICAL_ASSIST", True),
+        classical_assist_max_defects=env_int("HALIDE_CLASSICAL_ASSIST_MAX_DEFECTS", 32),
     )
 
 

data/schemas.py

@@ -269,6 +269,57 @@ def dedupe_defects(
     return merged, duplicate_count
 
 
+def filter_edge_artifacts(defects: Iterable[dict[str, Any]]) -> tuple[list[dict[str, Any]], int]:
+    """Drop repeated edge artifacts that look like film borders or sprockets."""
+    filtered: list[dict[str, Any]] = []
+    dropped = 0
+    for defect in defects:
+        label = str(defect.get("label", ""))
+        bbox = normalize_bbox(defect.get("bbox"))
+        if bbox is None:
+            dropped += 1
+            continue
+        if _is_edge_artifact(label, bbox, defect.get("confidence")):
+            dropped += 1
+            continue
+        filtered.append(_serialize_defect(label, bbox, defect))
+    return filtered, dropped
+
+
+def _is_edge_artifact(label: str, bbox: BBox, confidence: Any) -> bool:
+    x_min, y_min, x_max, y_max = bbox
+    width = x_max - x_min
+    height = y_max - y_min
+    area = width * height
+    center_x = (x_min + x_max) / 2.0
+
+    try:
+        confidence_value = float(confidence) if confidence is not None else None
+    except (TypeError, ValueError):
+        confidence_value = None
+
+    low_evidence = confidence_value is None or confidence_value < 0.62
+    if not low_evidence:
+        return False
+
+    if label == "dust" and area < 0.0016 and (center_x < 0.12 or center_x > 0.88):
+        return True
+
+    if width < 0.02 and height > 0.18 and (x_min <= 0.004 or x_max >= 0.996):
+        return True
+
+    if height < 0.02 and width > 0.22 and (y_min <= 0.004 or y_max >= 0.996):
+        return True
+
+    if label in {"scratch", "emulsion_damage"}:
+        if width < 0.075 and height > 0.22 and (x_min <= 0.006 or x_max >= 0.994):
+            return True
+        if height < 0.075 and width > 0.22 and (y_min <= 0.006 or y_max >= 0.994):
+            return True
+
+    return False
+
+
 def bbox_area(bbox: Any) -> float:
     norm = normalize_bbox(bbox)
     if norm is None:
@@ -361,6 +412,7 @@ __all__ = [
     "bbox_to_pixels",
     "clean_defects",
     "dedupe_defects",
+    "filter_edge_artifacts",
     "label_counts",
     "normalize_bbox",
     "spatial_summary",

models/vision/classical_assist.py

@@ -0,0 +1,274 @@
+"""Conservative image-analysis assist for obvious film defects.
+
+This module does not run a model. It uses local contrast only to catch clear
+linear scratches and compact bright debris that MiniCPM can miss on real scans.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+from PIL import Image, ImageFilter, ImageOps
+
+from data.schemas import bbox_area, bbox_iou, normalize_bbox
+
+
+@dataclass(frozen=True)
+class Candidate:
+    label: str
+    bbox: tuple[float, float, float, float]
+    score: float
+
+    def to_json(self) -> dict[str, Any]:
+        confidence = min(0.82, max(0.52, 0.5 + self.score * 0.72))
+        return {
+            "label": self.label,
+            "bbox": [round(v, 6) for v in self.bbox],
+            "confidence": round(confidence, 4),
+        }
+
+
+def detect_classical_defects(
+    image: Any,
+    *,
+    max_defects: int = 32,
+    include_compact_debris: bool = False,
+) -> list[dict[str, Any]]:
+    """Return high-precision defect candidates from image structure only."""
+    pil_image = ImageOps.exif_transpose(image.convert("RGB"))
+    width, height = pil_image.size
+    if width < 64 or height < 64:
+        return []
+
+    work = _resize_work_image(pil_image)
+    gray = _gray_array(work)
+    blur = _blur_array(gray, work.size)
+    residual = gray - blur
+    mask = _bright_residual_mask(gray, residual)
+
+    candidates: list[Candidate] = []
+    candidates.extend(_linear_candidates(mask, residual))
+    if include_compact_debris:
+        candidates.extend(_compact_debris_candidates(mask, residual))
+
+    candidates = _dedupe_candidates(candidates, max_defects=max(1, int(max_defects)))
+    return [candidate.to_json() for candidate in candidates]
+
+
+def _resize_work_image(image: Image.Image) -> Image.Image:
+    width, height = image.size
+    max_side = 1100
+    scale = min(1.0, max_side / float(max(width, height)))
+    if scale >= 1.0:
+        return image.copy()
+    new_size = (
+        max(1, int(round(width * scale))),
+        max(1, int(round(height * scale))),
+    )
+    return image.resize(new_size, Image.Resampling.LANCZOS)
+
+
+def _gray_array(image: Image.Image) -> np.ndarray:
+    arr = np.asarray(image).astype("float32") / 255.0
+    return (
+        0.2126 * arr[:, :, 0]
+        + 0.7152 * arr[:, :, 1]
+        + 0.0722 * arr[:, :, 2]
+    )
+
+
+def _blur_array(gray: np.ndarray, size: tuple[int, int]) -> np.ndarray:
+    width, height = size
+    radius = max(2, int(round(max(width, height) * 0.006)))
+    source = Image.fromarray(np.uint8(np.clip(gray * 255.0, 0, 255)))
+    blurred = source.filter(ImageFilter.GaussianBlur(radius=radius))
+    return np.asarray(blurred).astype("float32") / 255.0
+
+
+def _bright_residual_mask(gray: np.ndarray, residual: np.ndarray) -> np.ndarray:
+    threshold = max(0.045, float(np.percentile(residual, 99.2)))
+    mask = (residual >= threshold) & (gray > float(np.percentile(gray, 42)))
+    mask[:2, :] = False
+    mask[-2:, :] = False
+    mask[:, :2] = False
+    mask[:, -2:] = False
+    return mask
+
+
+def _linear_candidates(mask: np.ndarray, residual: np.ndarray) -> list[Candidate]:
+    height, width = mask.shape
+    min_horizontal = max(22, int(round(width * 0.035)))
+    min_vertical = max(22, int(round(height * 0.035)))
+    candidates: list[Candidate] = []
+
+    for y in range(height):
+        xs = np.flatnonzero(mask[y])
+        if xs.size == 0:
+            continue
+        for run in _contiguous_runs(xs):
+            if run.size < min_horizontal:
+                continue
+            x0, x1 = int(run[0]), int(run[-1]) + 1
+            pad = max(2, int(round(height * 0.003)))
+            bbox = (
+                x0 / width,
+                max(0, y - pad) / height,
+                x1 / width,
+                min(height, y + pad + 1) / height,
+            )
+            if _is_border_frame(bbox):
+                continue
+            candidates.append(
+                Candidate("scratch", bbox, float(residual[y, run].mean()))
+            )
+
+    for x in range(width):
+        ys = np.flatnonzero(mask[:, x])
+        if ys.size == 0:
+            continue
+        for run in _contiguous_runs(ys):
+            if run.size < min_vertical:
+                continue
+            y0, y1 = int(run[0]), int(run[-1]) + 1
+            pad = max(2, int(round(width * 0.003)))
+            bbox = (
+                max(0, x - pad) / width,
+                y0 / height,
+                min(width, x + pad + 1) / width,
+                y1 / height,
+            )
+            if _is_border_frame(bbox):
+                continue
+            candidates.append(
+                Candidate("scratch", bbox, float(residual[run, x].mean()))
+            )
+
+    return candidates
+
+
+def _compact_debris_candidates(mask: np.ndarray, residual: np.ndarray) -> list[Candidate]:
+    if int(mask.sum()) > 45_000:
+        return []
+
+    height, width = mask.shape
+    visited = np.zeros(mask.shape, dtype=bool)
+    points = np.argwhere(mask)
+    candidates: list[Candidate] = []
+
+    for y_raw, x_raw in points:
+        y = int(y_raw)
+        x = int(x_raw)
+        if visited[y, x] or not mask[y, x]:
+            continue
+        coords = _component(mask, visited, y, x, max_pixels=900)
+        if len(coords) < 3 or len(coords) > 850:
+            continue
+        ys = np.array([coord[0] for coord in coords], dtype=np.int32)
+        xs = np.array([coord[1] for coord in coords], dtype=np.int32)
+        x0 = int(xs.min())
+        x1 = int(xs.max()) + 1
+        y0 = int(ys.min())
+        y1 = int(ys.max()) + 1
+        box_width = x1 - x0
+        box_height = y1 - y0
+        if box_width > width * 0.1 or box_height > height * 0.1:
+            continue
+
+        aspect = max(box_width / max(1, box_height), box_height / max(1, box_width))
+        label = "scratch" if aspect >= 8.0 else "dust"
+        pad = 3 if label == "scratch" else 2
+        bbox = (
+            max(0, x0 - pad) / width,
+            max(0, y0 - pad) / height,
+            min(width, x1 + pad) / width,
+            min(height, y1 + pad) / height,
+        )
+        if _is_tiny_edge_artifact(bbox) or _is_border_frame(bbox):
+            continue
+        score = float(residual[ys, xs].mean())
+        candidates.append(Candidate(label, bbox, score))
+
+    return candidates
+
+
+def _component(
+    mask: np.ndarray,
+    visited: np.ndarray,
+    start_y: int,
+    start_x: int,
+    *,
+    max_pixels: int,
+) -> list[tuple[int, int]]:
+    height, width = mask.shape
+    stack = [(start_y, start_x)]
+    visited[start_y, start_x] = True
+    coords: list[tuple[int, int]] = []
+    while stack and len(coords) < max_pixels:
+        y, x = stack.pop()
+        coords.append((y, x))
+        for next_y in (y - 1, y, y + 1):
+            if next_y < 0 or next_y >= height:
+                continue
+            for next_x in (x - 1, x, x + 1):
+                if next_x < 0 or next_x >= width:
+                    continue
+                if visited[next_y, next_x] or not mask[next_y, next_x]:
+                    continue
+                visited[next_y, next_x] = True
+                stack.append((next_y, next_x))
+    return coords
+
+
+def _contiguous_runs(values: np.ndarray) -> list[np.ndarray]:
+    splits = np.where(np.diff(values) > 1)[0] + 1
+    return list(np.split(values, splits))
+
+
+def _dedupe_candidates(
+    candidates: list[Candidate],
+    *,
+    max_defects: int,
+) -> list[Candidate]:
+    kept: list[Candidate] = []
+    for candidate in sorted(candidates, key=lambda item: item.score, reverse=True):
+        if len(kept) >= max_defects:
+            break
+        bbox = normalize_bbox(candidate.bbox)
+        if bbox is None or bbox_area(bbox) <= 0:
+            continue
+        if any(_overlaps_existing(candidate, existing) for existing in kept):
+            continue
+        kept.append(candidate)
+    return kept
+
+
+def _overlaps_existing(candidate: Candidate, existing: Candidate) -> bool:
+    if bbox_iou(candidate.bbox, existing.bbox) >= 0.15:
+        return True
+    if candidate.label != "scratch" or existing.label != "scratch":
+        return False
+    cx0, cy0, cx1, cy1 = candidate.bbox
+    ex0, ey0, ex1, ey1 = existing.bbox
+    same_row = abs(((cy0 + cy1) / 2.0) - ((ey0 + ey1) / 2.0)) < 0.025
+    x_overlap = max(0.0, min(cx1, ex1) - max(cx0, ex0))
+    return same_row and x_overlap > 0.05
+
+
+def _is_border_frame(bbox: tuple[float, float, float, float]) -> bool:
+    x0, y0, x1, y1 = bbox
+    width = x1 - x0
+    height = y1 - y0
+    near_outer_edge = x0 < 0.012 or y0 < 0.012 or x1 > 0.988 or y1 > 0.988
+    return near_outer_edge and (width > 0.2 or height > 0.2)
+
+
+def _is_tiny_edge_artifact(bbox: tuple[float, float, float, float]) -> bool:
+    x0, y0, x1, y1 = bbox
+    area = max(0.0, x1 - x0) * max(0.0, y1 - y0)
+    center_x = (x0 + x1) / 2.0
+    return area < 0.0016 and (center_x < 0.12 or center_x > 0.88)
+
+
+__all__ = ["detect_classical_defects"]

models/vision/inference.py

@@ -7,8 +7,16 @@ from pathlib import Path
 from typing import Any
 
 from config import get_vision_config
-from data.schemas import BBox, clean_defects, dedupe_defects, label_counts, normalize_bbox
+from data.schemas import (
+    BBox,
+    clean_defects,
+    dedupe_defects,
+    filter_edge_artifacts,
+    label_counts,
+    normalize_bbox,
+)
 from data.preprocessing import load_image
+from models.vision.classical_assist import detect_classical_defects
 from models.vision.minicpm_wrapper import get_detector
 
 logger = logging.getLogger(__name__)
@@ -31,6 +39,9 @@ def extract_defects(image: Any) -> dict:
     tile_fallback_used = False
     tile_count = 0
     tile_parse_errors: list[str] = []
+    classical_assist_count = 0
+    classical_assist_used = False
+    edge_artifact_count = 0
 
     cfg = get_vision_config()
     if _should_run_tile_fallback(input_image, cleaned):
@@ -60,6 +71,24 @@ def extract_defects(image: Any) -> dict:
                 break
         cleaned = tile_defects
 
+    if cfg.classical_assist_enabled:
+        include_compact_debris = len(cleaned) == 0
+        classical_raw = detect_classical_defects(
+            input_image,
+            max_defects=cfg.classical_assist_max_defects,
+            include_compact_debris=include_compact_debris,
+        )
+        classical_cleaned, classical_dropped = clean_defects(classical_raw)
+        dropped += classical_dropped
+        if cleaned:
+            classical_cleaned = [
+                defect for defect in classical_cleaned if defect.get("label") == "scratch"
+            ]
+        classical_assist_count = len(classical_cleaned)
+        classical_assist_used = bool(classical_cleaned)
+        cleaned.extend(classical_cleaned)
+
+    cleaned, edge_artifact_count = filter_edge_artifacts(cleaned)
     cleaned, duplicate_count = dedupe_defects(cleaned)
     counts = label_counts(cleaned)
     elapsed = time.perf_counter() - started
@@ -70,6 +99,7 @@ def extract_defects(image: Any) -> dict:
         "label_counts": counts,
         "dropped_count": dropped,
         "duplicate_count": duplicate_count,
+        "edge_artifact_count": edge_artifact_count,
         "inference_seconds": round(elapsed, 3),
         "model_path": detector.model_path,
         "parse_error": raw.get("_parse_error"),
@@ -78,6 +108,8 @@ def extract_defects(image: Any) -> dict:
         "tile_count": tile_count,
         "full_frame_defect_count": full_frame_count,
         "tile_parse_errors": tile_parse_errors,
+        "classical_assist_used": classical_assist_used,
+        "classical_assist_count": classical_assist_count,
     }
 
 

ui/app.py

@@ -24,6 +24,7 @@ from ui.components import (
     LIGHTTABLE_EMPTY_STATE,
     LIGHTTABLE_RUNNING_STATE,
     REPORT_EMPTY_STATE,
+    comparison_viewer_html,
     confidence_notice_html,
     defect_table_rows,
     defect_pills_html,
@@ -245,11 +246,7 @@ def run_pipeline(
 
         counts = result.get("defects", {}).get("label_counts", {}) or {}
         defects = result.get("defects", {}).get("defects", []) or []
-        annotated = draw_defects(
-            pil_image,
-            defects,
-            title=f"Halide: {len(defects)} validated defects",
-        )
+        annotated = draw_defects(pil_image, defects)
         result = _attach_preview(result, pil_image, annotated)
         if not was_cached:
             try:
@@ -261,8 +258,10 @@ def run_pipeline(
         elif not result.get("diagnosis_id"):
             cache.put(image_bytes, result, metadata=metadata)
 
-        image_pair = (pil_image, annotated)
-        compare = gr.update(value=image_pair, visible=True)
+        compare = gr.update(
+            value=comparison_viewer_html(pil_image, annotated),
+            visible=True,
+        )
         gallery = gr.update(value=_review_gallery(pil_image, annotated), visible=True)
         review_links = gr.update(
             value=review_frame_html(pil_image, annotated),
@@ -446,15 +445,8 @@ def build_app() -> gr.Blocks:
                         "</div>"
                     )
                     lighttable_empty = gr.HTML(value=LIGHTTABLE_EMPTY_STATE)
-                    compare_output = gr.ImageSlider(
-                        value=None,
-                        label="Original / overlay",
-                        type="pil",
-                        height=620,
-                        max_height=680,
-                        slider_position=52,
-                        interactive=False,
-                        buttons=["download", "fullscreen"],
+                    compare_output = gr.HTML(
+                        value="",
                         elem_id="halide-compare",
                         visible=False,
                     )

ui/components.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import base64
+import functools
 import html
 import json
 import time
@@ -14,6 +15,7 @@ from data.schemas import LABEL_DISPLAY_NAMES
 from data.preprocessing import image_to_data_uri
 
 
+@functools.lru_cache(maxsize=1)
 def _logo_html() -> str:
     path = Path(__file__).resolve().parents[1] / "assets" / "logo.jpg"
     if not path.exists():
@@ -25,6 +27,9 @@ def _logo_html() -> str:
     )
 
 
+COMPARE_DEFAULT_SPLIT = 50
+
+
 HEADER_HTML = f"""
 <div id="halide-header">
   <div class="halide-brand-lockup">
@@ -126,7 +131,9 @@ def defect_table_rows(result: dict | None) -> list[list[str]]:
         else:
             box_text = "invalid"
         confidence = defect.get("confidence")
-        confidence_text = "" if confidence is None else f"{float(confidence):.2f}"
+        confidence_text = (
+            "not emitted" if confidence is None else f"{float(confidence):.2f}"
+        )
         rows.append([str(index), display, confidence_text, box_text])
     return rows
 
@@ -143,6 +150,8 @@ def stats_html(result: dict) -> str:
     rows.append(_stat_row("Total defects", str(defects.get("defect_count", 0))))
     rows.append(_stat_row("Dropped (invalid)", str(defects.get("dropped_count", 0))))
     rows.append(_stat_row("Duplicates removed", str(defects.get("duplicate_count", 0))))
+    rows.append(_stat_row("Edge artifacts removed", str(defects.get("edge_artifact_count", 0))))
+    rows.append(_stat_row("CV assist boxes", str(defects.get("classical_assist_count", 0))))
     rows.append(_stat_row("Resized for model", "yes" if defects.get("resized_for_model") else "no"))
     rows.append(_stat_row("Vision inference", f"{vision_s:.2f}s"))
     rows.append(_stat_row("Reasoning", f"{reasoning_s:.2f}s"))
@@ -191,6 +200,33 @@ def review_frame_html(original, annotated) -> str:
     )
 
 
+def comparison_viewer_html(original, annotated) -> str:
+    """Render an aligned before/after viewer using the same image canvas."""
+    original_uri = image_to_data_uri(original, max_side=1800, quality=92)
+    overlay_uri = image_to_data_uri(annotated, max_side=1800, quality=92)
+    return (
+        '<div class="halide-compare-viewer" '
+        f'style="--halide-split: {COMPARE_DEFAULT_SPLIT}%;">'
+        '<div class="halide-compare-stage">'
+        f'<img class="halide-compare-base" src="{original_uri}" alt="" />'
+        '<div class="halide-compare-overlay">'
+        f'<img src="{overlay_uri}" alt="" />'
+        "</div>"
+        '<div class="halide-compare-divider"></div>'
+        '<span class="halide-compare-label original">Original</span>'
+        '<span class="halide-compare-label overlay">Validated overlay</span>'
+        "</div>"
+        '<input class="halide-compare-range" type="range" min="0" max="100" '
+        f'value="{COMPARE_DEFAULT_SPLIT}" '
+        'aria-label="Compare original and validated overlay" '
+        'oninput="const viewer=this.closest('
+        "'.halide-compare-viewer'); "
+        "if (viewer) { viewer.style.setProperty('--halide-split', this.value + '%'); }"
+        '" />'
+        "</div>"
+    )
+
+
 def render_markdown_report(text: str) -> str:
     """Render the constrained diagnosis Markdown used by Nemotron.
 
@@ -327,10 +363,21 @@ def confidence_notice_html(result: dict) -> str:
     duplicate = int(defects.get("duplicate_count", 0) or 0)
     meta = result.get("film_metadata", {}) or {}
     confidence = str(meta.get("metadata_confidence", "low") or "low").lower()
+    confidence_values = [
+        defect.get("confidence")
+        for defect in defects.get("defects", []) or []
+        if defect.get("confidence") is not None
+    ]
 
     if total == 0:
         message = "No validated boxes were returned. Inspect the scan before assuming a film fault."
         tone = "neutral"
+    elif not confidence_values:
+        message = (
+            "Defect boxes passed schema validation. MiniCPM did not emit numeric "
+            "per-box confidence for this run."
+        )
+        tone = "good"
     elif confidence == "low":
         message = "Metadata is marked low confidence, so the diagnosis is driven mainly by visible defects."
         tone = "caution"
@@ -501,6 +548,7 @@ __all__ = [
     "LIGHTTABLE_RUNNING_STATE",
     "REPORT_EMPTY_STATE",
     "compact_label_counts",
+    "comparison_viewer_html",
     "confidence_notice_html",
     "defect_table_rows",
     "defect_pills_html",

ui/theme.py

@@ -4,23 +4,23 @@ from __future__ import annotations
 
 import gradio as gr
 
-BRASS = "#c59a52"
-BRASS_DARK = "#8a6431"
-COPPER = "#b85f3f"
-TEAL = "#66d4c1"
-VIOLET = "#9d8cff"
-RED = "#ef5d52"
-
-INK = "#0a0a0a"
-CARBON = "#111111"
-SURFACE = "#181715"
-SURFACE_SOFT = "#211f1c"
-SURFACE_LIFT = "#2c2924"
-PAPER = "#f3eadb"
-PAPER_SOFT = "#d7cbb8"
-MUTED = "#a99b88"
-BORDER = "#3a352e"
-BLACK = "#050505"
+BRASS = "#d29a45"
+BRASS_DARK = "#8c5a1f"
+COPPER = "#be5f38"
+TEAL = "#9aae6f"
+VIOLET = "#8b5e4f"
+RED = "#d85c45"
+
+INK = "#100d0a"
+CARBON = "#17110d"
+SURFACE = "#1f1711"
+SURFACE_SOFT = "#2b2118"
+SURFACE_LIFT = "#3a2b1f"
+PAPER = "#fff0d8"
+PAPER_SOFT = "#e6d1b6"
+MUTED = "#b89c77"
+BORDER = "#5a432f"
+BLACK = "#080604"
 
 THEME_CSS = f"""
 :root {{
@@ -60,8 +60,8 @@ body::before {{
   background:
     repeating-linear-gradient(
       90deg,
-      rgba(255, 255, 255, 0.018) 0,
-      rgba(255, 255, 255, 0.018) 1px,
+      rgba(255, 240, 216, 0.018) 0,
+      rgba(255, 240, 216, 0.018) 1px,
       transparent 1px,
       transparent 16px
     );
@@ -127,7 +127,7 @@ body::before {{
   display: flex;
   flex-wrap: wrap;
   justify-content: flex-end;
-  gap: 8px;
+  gap: 10px;
   min-width: min(42vw, 36rem);
 }}
 
@@ -137,17 +137,18 @@ body::before {{
   color: var(--halide-paper);
   background: rgba(24, 23, 21, 0.92);
   border-radius: 8px;
-  padding: 8px 10px;
+  padding: 9px 13px;
   font-size: 0.76rem;
   font-weight: 780;
-  line-height: 1;
+  line-height: 1.08;
   text-decoration: none;
   white-space: nowrap;
 }}
 
 .halide-model-strip a {{
-  color: #dffcf6;
-  border-color: rgba(102, 212, 193, 0.38);
+  color: #f5dfac;
+  border-color: rgba(154, 174, 111, 0.42);
+  background: rgba(58, 43, 31, 0.92);
 }}
 
 .halide-workbench {{
@@ -188,8 +189,8 @@ body::before {{
 }}
 
 .halide-model-card {{
-  border: 1px solid rgba(102, 212, 193, 0.28);
-  background: rgba(102, 212, 193, 0.055);
+  border: 1px solid rgba(154, 174, 111, 0.30);
+  background: rgba(154, 174, 111, 0.075);
   border-radius: 8px;
   padding: 12px;
   margin-top: 12px;
@@ -243,11 +244,11 @@ body::before {{
 }}
 
 .halide-run-state.active {{
-  border-color: rgba(102, 212, 193, 0.46);
+  border-color: rgba(154, 174, 111, 0.48);
 }}
 
 .halide-run-state.quiet {{
-  border-color: rgba(157, 140, 255, 0.35);
+  border-color: rgba(139, 94, 79, 0.38);
 }}
 
 .halide-run-eyebrow {{
@@ -259,7 +260,7 @@ body::before {{
 }}
 
 .halide-lighttable {{
-  background: #0f0f0e !important;
+  background: #120d09 !important;
   border: 1px solid rgba(197, 154, 82, 0.34) !important;
   border-radius: 8px !important;
   padding: 13px !important;
@@ -358,11 +359,11 @@ body::before {{
 }}
 
 .halide-empty-lighttable.active {{
-  border-color: rgba(102, 212, 193, 0.34);
+  border-color: rgba(154, 174, 111, 0.36);
 }}
 
 .halide-empty-lighttable.active .halide-empty-center {{
-  border-color: rgba(102, 212, 193, 0.42);
+  border-color: rgba(154, 174, 111, 0.44);
 }}
 
 .halide-empty-lighttable.active .halide-empty-center span {{
@@ -403,7 +404,6 @@ body::before {{
   line-height: 1;
 }}
 
-#halide-compare,
 .halide-review-gallery {{
   background: var(--halide-black) !important;
 }}
@@ -413,12 +413,95 @@ body::before {{
 }}
 
 .halide-upload img,
-#halide-compare img,
 .halide-review-gallery img {{
   background: var(--halide-black) !important;
   object-fit: contain !important;
 }}
 
+#halide-compare {{
+  min-height: 0 !important;
+}}
+
+.halide-compare-viewer {{
+  display: grid;
+  gap: 12px;
+  background: var(--halide-black);
+  border: 1px solid rgba(255, 240, 216, 0.16);
+  border-radius: 8px;
+  padding: 12px;
+}}
+
+.halide-compare-stage {{
+  position: relative;
+  min-height: clamp(380px, 58vh, 720px);
+  overflow: hidden;
+  display: grid;
+  place-items: center;
+  background:
+    linear-gradient(180deg, rgba(31, 23, 17, 0.82), rgba(8, 6, 4, 0.98)),
+    repeating-linear-gradient(
+      90deg,
+      rgba(210, 154, 69, 0.055) 0,
+      rgba(210, 154, 69, 0.055) 1px,
+      transparent 1px,
+      transparent 34px
+    );
+  border-radius: 7px;
+}}
+
+.halide-compare-stage img {{
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  object-fit: contain;
+  background: var(--halide-black);
+}}
+
+.halide-compare-overlay {{
+  position: absolute;
+  inset: 0;
+  clip-path: inset(0 calc(100% - var(--halide-split)) 0 0);
+}}
+
+.halide-compare-divider {{
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: var(--halide-split);
+  width: 2px;
+  transform: translateX(-1px);
+  background: rgba(255, 240, 216, 0.88);
+  box-shadow: 0 0 0 1px rgba(8, 6, 4, 0.70), 0 0 18px rgba(190, 95, 56, 0.38);
+}}
+
+.halide-compare-label {{
+  position: absolute;
+  top: 12px;
+  z-index: 2;
+  border: 1px solid rgba(255, 240, 216, 0.20);
+  background: rgba(16, 13, 10, 0.78);
+  color: var(--halide-paper);
+  border-radius: 999px;
+  padding: 6px 9px;
+  font-size: 0.70rem;
+  font-weight: 820;
+  line-height: 1;
+}}
+
+.halide-compare-label.original {{
+  left: 12px;
+}}
+
+.halide-compare-label.overlay {{
+  right: 12px;
+}}
+
+.halide-compare-range {{
+  width: 100%;
+  accent-color: var(--halide-copper);
+}}
+
 #halide-run-button,
 button.primary,
 .primary button {{
@@ -511,8 +594,8 @@ button {{
 }}
 
 .halide-notice.good {{
-  border-color: rgba(102, 212, 193, 0.38);
-  background: rgba(102, 212, 193, 0.075);
+  border-color: rgba(154, 174, 111, 0.40);
+  background: rgba(154, 174, 111, 0.085);
 }}
 
 .halide-notice.caution {{
@@ -521,8 +604,8 @@ button {{
 }}
 
 .halide-notice.neutral {{
-  border-color: rgba(157, 140, 255, 0.36);
-  background: rgba(157, 140, 255, 0.075);
+  border-color: rgba(139, 94, 79, 0.38);
+  background: rgba(139, 94, 79, 0.085);
 }}
 
 .halide-stats {{
@@ -646,13 +729,13 @@ button {{
 }}
 
 .halide-defect-pill.long_hair {{
-  background: rgba(157, 140, 255, 0.13);
-  border-color: rgba(157, 140, 255, 0.38);
+  background: rgba(139, 94, 79, 0.14);
+  border-color: rgba(139, 94, 79, 0.40);
 }}
 
 .halide-defect-pill.short_hair {{
-  background: rgba(102, 212, 193, 0.11);
-  border-color: rgba(102, 212, 193, 0.36);
+  background: rgba(154, 174, 111, 0.12);
+  border-color: rgba(154, 174, 111, 0.38);
 }}
 
 .halide-defect-pill.emulsion_damage {{
@@ -661,8 +744,8 @@ button {{
 }}
 
 .halide-defect-pill.chemical_stain {{
-  background: rgba(74, 222, 128, 0.12);
-  border-color: rgba(74, 222, 128, 0.34);
+  background: rgba(154, 174, 111, 0.13);
+  border-color: rgba(154, 174, 111, 0.38);
 }}
 
 .halide-defect-pill.light_leak {{
@@ -888,11 +971,6 @@ footer a:hover {{
   z-index: 1;
 }}
 
-#halide-compare {{
-  min-height: 520px !important;
-  border: 1px solid rgba(243, 234, 219, 0.16) !important;
-}}
-
 .halide-review-actions {{
   display: flex;
   flex-wrap: wrap;
@@ -908,9 +986,9 @@ footer a:hover {{
   min-height: 36px;
   padding: 0 12px;
   border-radius: 8px;
-  border: 1px solid rgba(102, 212, 193, 0.34);
-  background: rgba(102, 212, 193, 0.08);
-  color: #dffcf6 !important;
+  border: 1px solid rgba(154, 174, 111, 0.38);
+  background: rgba(154, 174, 111, 0.09);
+  color: #f5dfac !important;
   text-decoration: none !important;
   font-size: 0.78rem;
   font-weight: 820;
@@ -918,8 +996,8 @@ footer a:hover {{
 
 .halide-review-actions a:hover,
 .halide-history-preview-actions a:hover {{
-  border-color: rgba(102, 212, 193, 0.62);
-  background: rgba(102, 212, 193, 0.13);
+  border-color: rgba(154, 174, 111, 0.62);
+  background: rgba(154, 174, 111, 0.14);
 }}
 
 .halide-report-subheading {{
@@ -938,9 +1016,9 @@ footer a:hover {{
 }}
 
 .halide-report-body code {{
-  color: #dffcf6;
-  background: rgba(102, 212, 193, 0.10);
-  border: 1px solid rgba(102, 212, 193, 0.22);
+  color: #f5dfac;
+  background: rgba(154, 174, 111, 0.10);
+  border: 1px solid rgba(154, 174, 111, 0.24);
   border-radius: 5px;
   padding: 1px 5px;
 }}
@@ -1104,7 +1182,7 @@ footer a:hover {{
     height: 190px !important;
   }}
 
-  #halide-compare {{
+  .halide-compare-stage {{
     min-height: 360px !important;
   }}
 
@@ -1143,17 +1221,17 @@ def build_theme() -> gr.Theme:
             c950="#1c1209",
         ),
         secondary_hue=gr.themes.Color(
-            c50="#effffb",
-            c100="#d5fff7",
-            c200="#a8f5ea",
+            c50="#f8faec",
+            c100="#eef3d1",
+            c200="#dbe6a9",
             c300=TEAL,
-            c400="#3fbfae",
-            c500="#259d90",
-            c600="#1d7d74",
-            c700="#1b645e",
-            c800="#174d49",
-            c900="#123c39",
-            c950="#071f1d",
+            c400="#7f9857",
+            c500="#667a43",
+            c600="#506236",
+            c700="#3e4d2b",
+            c800="#303c22",
+            c900="#252f1b",
+            c950="#131a0d",
         ),
         neutral_hue=gr.themes.Color(
             c50="#fbf7ef",