Update app.py

app.py

@@ -1,1113 +1,998 @@
 """
-Blueprint Room Extractor — Flask Server
+FloorPlan Analyser — Gradio Application
+========================================
+Pipeline (mirrors GeometryAgent v5):
+  1. Load image
+  2. Crop title block
+  3. Remove colors (chroma filter)
+  4. Extract walls adaptive
+  5. User draws door-closing lines (optional, before SAM)
+  6. Segment rooms with SAM (HuggingFace hosted)
+  7. OCR → validate room labels
+  8. Annotate + measure (area in m²)
+  9. Export to Excel
+Optional:
+  • Click to select / deselect room
+  • Remove wrong annotation
+  • Pan / Zoom (Gradio native)
+  • Draw lines to close doors on the wall mask
 """
+
 from __future__ import annotations
 
-import base64
-import io
-import json
-import os
-import threading
-import time
-import traceback
-import uuid
-from typing import Any, Dict, List, Optional
+import io, json, os, tempfile, time, requests
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
 
 import cv2
 import numpy as np
-from flask import Flask, Response, jsonify, render_template_string, request
-from PIL import Image
-
-from wall_pipeline import WallPipeline, _CUPY, _TORCH_CUDA, _CV_CUDA
-
-# Unified "any GPU active" flag for the UI badge
-_GPU = _CUPY or _TORCH_CUDA or _CV_CUDA
-
-app = Flask(__name__)
-
-# ── In-memory session store ──────────────────────────────────────────────────
-_sessions: Dict[str, Dict] = {}
-_sessions_lock = threading.Lock()
-
-
-def _new_session() -> str:
-    sid = str(uuid.uuid4())
-    with _sessions_lock:
-        _sessions[sid] = {
-            "original_bgr"  : None,   # np.ndarray
-            "wall_mask"     : None,
-            "room_mask"     : None,
-            "rooms"         : [],      # list of room dicts
-            "stage_images"  : {},      # key -> np.ndarray
-            "calibration"   : {},
-            "door_lines"    : [],      # manual door seal lines [(x1,y1,x2,y2),...]
-            "log"           : [],
-            "progress"      : 0,
-            "status"        : "idle",
-        }
-    return sid
-
-
-def _get_session(sid: str) -> Optional[Dict]:
-    with _sessions_lock:
-        return _sessions.get(sid)
-
-
-# ── Image helpers ─────────────────────────────────────────────────────────────
-def _bgr_to_b64(img: np.ndarray, max_dim: int = 2048) -> str:
-    h, w = img.shape[:2]
-    if max(h, w) > max_dim:
-        scale = max_dim / max(h, w)
-        img   = cv2.resize(img, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_AREA)
-    _, buf = cv2.imencode(".jpg", img, [cv2.IMWRITE_JPEG_QUALITY, 88])
-    return base64.b64encode(buf.tobytes()).decode()
-
-
-def _mask_to_b64(mask: np.ndarray, max_dim: int = 2048) -> str:
-    vis = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
-    return _bgr_to_b64(vis, max_dim)
-
-
-def _composite_overlay(orig: np.ndarray, rooms: List[Dict],
-                         wall_mask: np.ndarray) -> np.ndarray:
-    """Render original image + wall overlay + room polygons."""
-    vis = orig.copy()
-    # Overlay walls (semi-transparent blue)
-    if wall_mask is not None:
-        wm = wall_mask
-        if wm.shape[:2] != vis.shape[:2]:
-            wm = cv2.resize(wm, (vis.shape[1], vis.shape[0]),
-                            interpolation=cv2.INTER_NEAREST)
-        wall_vis = np.zeros_like(vis)
-        wall_vis[wm > 0] = (0, 80, 220)
-        vis = cv2.addWeighted(vis, 0.85, wall_vis, 0.4, 0)
-    # Draw room fills
-    rng = np.random.default_rng(7)
-    for room in rooms:
-        color = rng.integers(80, 200, 3).tolist()
-        segs  = room.get("segmentation", [])
-        for seg in segs:
-            pts = np.array(seg, dtype=np.int32).reshape(-1, 2)
-            if len(pts) >= 3:
-                overlay = vis.copy()
-                cv2.fillPoly(overlay, [pts], color)
-                vis = cv2.addWeighted(vis, 0.55, overlay, 0.45, 0)
-                cv2.polylines(vis, [pts], True, color, 2)
-        # Label
-        cx, cy = room.get("centroid", [0, 0])
-        label  = room.get("label", f"#{room['id']}")
-        cv2.putText(vis, label, (cx-20, cy),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.55, (255,255,255), 2, cv2.LINE_AA)
-        cv2.putText(vis, str(room["id"]), (cx-6, cy+18),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.45, (220,220,0), 1, cv2.LINE_AA)
+import gradio as gr
+import openpyxl
+from openpyxl.styles import Font, PatternFill, Alignment
+
+# ─── SAM HuggingFace endpoint ───────────────────────────────────────────────
+HF_REPO   = "Pream912/sam"
+HF_API    = f"https://huggingface.co/{HF_REPO}/resolve/main"
+# We'll download the checkpoint locally on first use
+SAM_CKPT  = Path(tempfile.gettempdir()) / "sam_vit_h_4b8939.pth"
+SAM_URL   = f"{HF_API}/sam_vit_h_4b8939.pth"
+
+DPI          = 300
+SCALE_FACTOR = 100   # 1 px = 1/300 inch × 100 cm scale
+
+# ─── constants (ported from GeometryAgent) ──────────────────────────────────
+MIN_ROOM_AREA_FRAC = 0.000004
+MAX_ROOM_AREA_FRAC = 0.08
+MIN_ROOM_DIM_FRAC  = 0.01
+BORDER_MARGIN_FRAC = 0.01
+MAX_ASPECT_RATIO   = 8.0
+MIN_SOLIDITY       = 0.25
+MIN_EXTENT         = 0.08
+OCR_CONF_THR       = 0.3
+SAM_MIN_SCORE      = 0.70
+SAM_CLOSET_THR     = 300
+SAM_WALL_NEG       = 20
+SAM_WALL_PCT       = 75
+WALL_MIN_HALF_PX   = 3
+
+ROOM_COLORS = [
+    (255, 99,  71), (100, 149, 237), (60,  179, 113),
+    (255, 165,   0), (147, 112, 219), (0,  206, 209),
+    (255, 182, 193), (127, 255,   0), (255, 215,   0),
+    (176, 224, 230),
+]
+
+# ════════════════════════════════════════════════════════════════════════════
+#  PIPELINE HELPERS
+# ════════════════════════════════════════════════════════════════════════════
+
+def download_sam_if_needed() -> Optional[str]:
+    if SAM_CKPT.exists():
+        return str(SAM_CKPT)
+    print(f"[SAM] Downloading checkpoint from HuggingFace …")
+    try:
+        r = requests.get(SAM_URL, stream=True, timeout=300)
+        r.raise_for_status()
+        with open(SAM_CKPT, "wb") as f:
+            for chunk in r.iter_content(1 << 20):
+                f.write(chunk)
+        print(f"[SAM] Saved to {SAM_CKPT}")
+        return str(SAM_CKPT)
+    except Exception as e:
+        print(f"[SAM] Download failed: {e}")
+        return None
+
+
+def remove_title_block(img: np.ndarray) -> np.ndarray:
+    h, w  = img.shape[:2]
+    gray  = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    edges = cv2.Canny(gray, 50, 150)
+
+    h_kern  = cv2.getStructuringElement(cv2.MORPH_RECT, (w // 20, 1))
+    v_kern  = cv2.getStructuringElement(cv2.MORPH_RECT, (1, h // 20))
+    h_lines = cv2.morphologyEx(edges, cv2.MORPH_OPEN, h_kern)
+    v_lines = cv2.morphologyEx(edges, cv2.MORPH_OPEN, v_kern)
+
+    crop_r, crop_b = w, h
+
+    right_region = v_lines[:, int(w * 0.7):]
+    if np.any(right_region):
+        v_pos = np.where(np.sum(right_region, axis=0) > h * 0.3)[0]
+        if len(v_pos):
+            crop_r = int(w * 0.7) + v_pos[0] - 10
+
+    bot_region = h_lines[int(h * 0.7):, :]
+    if np.any(bot_region):
+        h_pos = np.where(np.sum(bot_region, axis=1) > w * 0.3)[0]
+        if len(h_pos):
+            crop_b = int(h * 0.7) + h_pos[0] - 10
+
+    if crop_r == w and crop_b == h:
+        main_d = np.sum(gray < 200) / gray.size
+        if np.sum(gray[:, int(w*0.8):] < 200) / (gray[:, int(w*0.8):].size) > main_d*1.5:
+            crop_r = int(w * 0.8)
+        if np.sum(gray[int(h*0.8):, :] < 200) / (gray[int(h*0.8):, :].size) > main_d*1.5:
+            crop_b = int(h * 0.8)
+
+    return img[:crop_b, :crop_r].copy()
+
+
+def remove_colors(img: np.ndarray) -> np.ndarray:
+    b = img[:,:,0].astype(np.int32)
+    g = img[:,:,1].astype(np.int32)
+    r = img[:,:,2].astype(np.int32)
+    gray   = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype(np.int32)
+    chroma = np.maximum(np.maximum(r,g),b) - np.minimum(np.minimum(r,g),b)
+    erase  = (chroma > 15) & (gray < 240)
+    result = img.copy()
+    result[erase] = (255, 255, 255)
+    return result
+
+
+def estimate_wall_thickness(binary: np.ndarray, fallback: int = 12) -> int:
+    h, w = binary.shape
+    n_cols = min(200, w)
+    col_idx = np.linspace(0, w-1, n_cols, dtype=int)
+    runs = []
+    for ci in col_idx:
+        col = (binary[:, ci] > 0).astype(np.int8)
+        pad = np.concatenate([[0], col, [0]])
+        d   = np.diff(pad.astype(np.int16))
+        s   = np.where(d ==  1)[0]
+        e   = np.where(d == -1)[0]
+        n   = min(len(s), len(e))
+        r   = (e[:n] - s[:n]).astype(int)
+        runs.extend(r[(r >= 2) & (r <= h*0.15)].tolist())
+    if runs:
+        return max(6, int(np.median(runs)))
+    return fallback
+
+
+def extract_walls_adaptive(img_clean: np.ndarray) -> Tuple[np.ndarray, int]:
+    h, w   = img_clean.shape[:2]
+    gray   = cv2.cvtColor(img_clean, cv2.COLOR_BGR2GRAY)
+    otsu_t, binary = cv2.threshold(
+        gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU
+    )
+    wall_threshold = int(otsu_t)
+    _, binary = cv2.threshold(gray, wall_threshold, 255, cv2.THRESH_BINARY_INV)
+
+    min_line_len   = max(8, int(0.012 * w))
+    body_thickness = estimate_wall_thickness(binary)
+    body_thickness = int(np.clip(body_thickness, 9, 30))
+
+    k_h = cv2.getStructuringElement(cv2.MORPH_RECT, (min_line_len, 1))
+    k_v = cv2.getStructuringElement(cv2.MORPH_RECT, (1, min_line_len))
+    long_h = cv2.morphologyEx(binary, cv2.MORPH_OPEN, k_h)
+    long_v = cv2.morphologyEx(binary, cv2.MORPH_OPEN, k_v)
+    orig_walls = cv2.bitwise_or(long_h, long_v)
+
+    k_bh = cv2.getStructuringElement(cv2.MORPH_RECT, (1, body_thickness))
+    k_bv = cv2.getStructuringElement(cv2.MORPH_RECT, (body_thickness, 1))
+    dil_h = cv2.dilate(long_h, k_bh)
+    dil_v = cv2.dilate(long_v, k_bv)
+    walls = cv2.bitwise_or(dil_h, dil_v)
+
+    collision = cv2.bitwise_and(dil_h, dil_v)
+    safe_zone = cv2.bitwise_and(collision, orig_walls)
+    walls = cv2.bitwise_or(
+        cv2.bitwise_and(walls, cv2.bitwise_not(collision)), safe_zone
+    )
+
+    dist      = cv2.distanceTransform(cv2.bitwise_not(orig_walls), cv2.DIST_L2, 5)
+    keep_mask = (dist <= body_thickness / 2).astype(np.uint8) * 255
+    walls     = cv2.bitwise_and(walls, keep_mask)
+
+    # noise removal
+    n_lbl, labels, stats, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
+    if n_lbl > 1:
+        areas    = stats[1:, cv2.CC_STAT_AREA]
+        min_n    = max(20, int(np.median(areas) * 0.0001))
+        keep_lut = np.zeros(n_lbl, dtype=np.uint8)
+        keep_lut[1:] = (areas >= min_n).astype(np.uint8)
+        walls = (keep_lut[labels] * 255).astype(np.uint8)
+
+    return walls, body_thickness
+
+
+def apply_user_lines_to_walls(
+    walls: np.ndarray,
+    lines: List[Tuple[int,int,int,int]],
+    thickness: int,
+) -> np.ndarray:
+    """Paint user-drawn door-closing lines onto the wall mask."""
+    result = walls.copy()
+    for x1, y1, x2, y2 in lines:
+        cv2.line(result, (x1, y1), (x2, y2), 255, max(thickness, 3))
+    return result
+
+
+def segment_rooms_flood(walls: np.ndarray) -> np.ndarray:
+    h, w = walls.shape
+    walls[:5, :] = 255; walls[-5:, :] = 255
+    walls[:, :5] = 255; walls[:, -5:] = 255
+
+    filled = walls.copy()
+    mask   = np.zeros((h+2, w+2), np.uint8)
+    for sx, sy in [(0,0),(w-1,0),(0,h-1),(w-1,h-1),
+                   (w//2,0),(w//2,h-1),(0,h//2),(w-1,h//2)]:
+        if filled[sy, sx] == 0:
+            cv2.floodFill(filled, mask, (sx, sy), 255)
+
+    rooms = cv2.bitwise_not(filled)
+    rooms = cv2.bitwise_and(rooms, cv2.bitwise_not(walls))
+    rooms = cv2.morphologyEx(rooms, cv2.MORPH_OPEN, np.ones((2,2), np.uint8))
+    return rooms
+
+
+def _morphological_skeleton(binary: np.ndarray) -> np.ndarray:
+    skel  = np.zeros_like(binary)
+    img   = binary.copy()
+    cross = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3))
+    for _ in range(300):
+        eroded = cv2.erode(img, cross)
+        temp   = cv2.subtract(img, cv2.dilate(eroded, cross))
+        skel   = cv2.bitwise_or(skel, temp)
+        img    = eroded
+        if not cv2.countNonZero(img):
+            break
+    return skel
+
+
+def _find_thick_wall_neg_prompts(
+    walls_mask: np.ndarray, n: int = SAM_WALL_NEG
+) -> List[Tuple[int,int]]:
+    h, w = walls_mask.shape
+    dist = cv2.distanceTransform(walls_mask, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
+    try:
+        skel = cv2.ximgproc.thinning(
+            walls_mask, thinningType=cv2.ximgproc.THINNING_ZHANGSUEN
+        )
+    except AttributeError:
+        skel = _morphological_skeleton(walls_mask)
+
+    skel_vals = dist[skel > 0]
+    if len(skel_vals) == 0:
+        return []
+    thr = max(float(np.percentile(skel_vals, SAM_WALL_PCT)), WALL_MIN_HALF_PX)
+    ys, xs = np.where((skel > 0) & (dist >= thr))
+    if len(ys) == 0:
+        return []
+
+    grid_cells = max(1, int(np.ceil(np.sqrt(n * 4))))
+    cell_h     = max(1, h // grid_cells)
+    cell_w     = max(1, w // grid_cells)
+    cell_ids   = (ys // cell_h) * grid_cells + (xs // cell_w)
+    _, first   = np.unique(cell_ids, return_index=True)
+    sel        = first[:n]
+    return [(int(xs[i]), int(ys[i])) for i in sel]
+
+
+def generate_prompts(
+    walls_mask: np.ndarray, rooms_flood: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray]:
+    h, w = walls_mask.shape
+    inv  = cv2.bitwise_not(walls_mask)
+    n, labels, stats, centroids = cv2.connectedComponentsWithStats(inv, connectivity=8)
+
+    pts, lbls = [], []
+    for i in range(1, n):
+        area = int(stats[i, cv2.CC_STAT_AREA])
+        if area < SAM_CLOSET_THR:
+            continue
+        bx = int(stats[i, cv2.CC_STAT_LEFT]); by = int(stats[i, cv2.CC_STAT_TOP])
+        bw = int(stats[i, cv2.CC_STAT_WIDTH]); bh = int(stats[i, cv2.CC_STAT_HEIGHT])
+        if bx <= 5 and by <= 5 and bx+bw >= w-5 and by+bh >= h-5:
+            continue
+        cx = int(np.clip(centroids[i][0], 0, w-1))
+        cy = int(np.clip(centroids[i][1], 0, h-1))
+        if walls_mask[cy, cx] > 0:
+            found = False
+            for dy in range(-10, 11, 2):
+                for dx in range(-10, 11, 2):
+                    ny2, nx2 = cy+dy, cx+dx
+                    if 0<=ny2<h and 0<=nx2<w and walls_mask[ny2,nx2]==0:
+                        cx, cy = nx2, ny2; found = True; break
+                if found: break
+            if not found: continue
+        pts.append([cx, cy]); lbls.append(1)
+
+    for pt in _find_thick_wall_neg_prompts(walls_mask):
+        pts.append(list(pt)); lbls.append(0)
+
+    return np.array(pts, dtype=np.float32), np.array(lbls, dtype=np.int32)
+
+
+def mask_to_rle(mask: np.ndarray) -> Dict:
+    h, w = mask.shape
+    flat = mask.flatten(order='F').astype(bool)
+    counts, run, cur = [], 0, False
+    for v in flat:
+        if v == cur: run += 1
+        else: counts.append(run); run = 1; cur = v
+    counts.append(run)
+    if mask[0, 0]: counts.insert(0, 0)
+    return {"counts": counts, "size": [h, w]}
+
+
+def segment_with_sam(
+    img_rgb: np.ndarray,
+    walls: np.ndarray,
+    sam_ckpt: str,
+) -> List[Dict]:
+    """Returns list of room dicts with keys: mask, score, prompt."""
+    rooms_flood = segment_rooms_flood(walls.copy())
+
+    try:
+        import torch
+        from segment_anything import sam_model_registry, SamPredictor
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        sam    = sam_model_registry["vit_h"](checkpoint=sam_ckpt)
+        sam.to(device); sam.eval()
+        predictor = SamPredictor(sam)
+    except Exception as e:
+        print(f"[SAM] Load failed: {e} — fallback to flood-fill")
+        return _flood_fill_rooms(rooms_flood)
+
+    pts, lbls = generate_prompts(walls, rooms_flood)
+    if len(pts) == 0:
+        return _flood_fill_rooms(rooms_flood)
+
+    predictor.set_image(img_rgb)
+    pos_pts = [(tuple(p), int(l)) for p, l in zip(pts, lbls) if l == 1]
+    neg_pts = [tuple(p) for p, l in zip(pts, lbls) if l == 0]
+
+    neg_coords = np.array(neg_pts, dtype=np.float32) if neg_pts else None
+    neg_lbls   = np.zeros(len(neg_pts), dtype=np.int32) if neg_pts else None
+    denoise_k  = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
+
+    results = []
+    for (px, py), lbl in pos_pts:
+        if neg_coords is not None:
+            pt_c = np.vstack([[[px, py]], neg_coords])
+            pt_l = np.concatenate([[lbl], neg_lbls])
+        else:
+            pt_c = np.array([[px, py]], dtype=np.float32)
+            pt_l = np.array([lbl],      dtype=np.int32)
+
+        masks, scores, _ = predictor.predict(
+            point_coords=pt_c, point_labels=pt_l, multimask_output=True
+        )
+        best = int(np.argmax(scores))
+        if float(scores[best]) < SAM_MIN_SCORE: continue
+
+        m = (masks[best] > 0).astype(np.uint8) * 255
+        m = cv2.bitwise_and(m, rooms_flood)
+        m = cv2.morphologyEx(m, cv2.MORPH_OPEN, denoise_k)
+        if not np.any(m): continue
+
+        results.append({"mask": m, "score": float(scores[best]), "prompt": (px, py)})
+
+    if not results:
+        return _flood_fill_rooms(rooms_flood)
+    return results
+
+
+def _flood_fill_rooms(rooms_flood: np.ndarray) -> List[Dict]:
+    contours, _ = cv2.findContours(
+        rooms_flood, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+    results = []
+    for cnt in contours:
+        m = np.zeros_like(rooms_flood)
+        cv2.drawContours(m, [cnt], -1, 255, -1)
+        M  = cv2.moments(cnt)
+        cx = int(M["m10"]/M["m00"]) if M["m00"] else 0
+        cy = int(M["m01"]/M["m00"]) if M["m00"] else 0
+        results.append({"mask": m, "score": 1.0, "prompt": (cx, cy)})
+    return results
+
+
+def filter_room_masks(
+    room_masks: List[Dict], img_shape: Tuple
+) -> List[Dict]:
+    h, w     = img_shape[:2]
+    img_area = float(h * w)
+    min_area = img_area * MIN_ROOM_AREA_FRAC
+    max_area = img_area * MAX_ROOM_AREA_FRAC
+    min_dim  = w        * MIN_ROOM_DIM_FRAC
+    margin   = max(5.0, w * BORDER_MARGIN_FRAC)
+
+    valid = []
+    for entry in room_masks:
+        m = entry["mask"]
+        cnts, _ = cv2.findContours(m, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        if not cnts: continue
+        cnt  = max(cnts, key=cv2.contourArea)
+        area = cv2.contourArea(cnt)
+        if not (min_area <= area <= max_area): continue
+        bx, by, bw, bh = cv2.boundingRect(cnt)
+        if bx < margin or by < margin or bx+bw > w-margin or by+bh > h-margin:
+            continue
+        if bw < min_dim and bh < min_dim: continue
+        asp = max(bw, bh) / (min(bw, bh) + 1e-6)
+        if asp > MAX_ASPECT_RATIO: continue
+        if (area / (bw*bh+1e-6)) < MIN_EXTENT: continue
+        hull = cv2.convexHull(cnt)
+        ha   = cv2.contourArea(hull)
+        if ha > 0 and (area / ha) < MIN_SOLIDITY: continue
+
+        entry = dict(entry)
+        entry["contour"] = cnt
+        entry["area_px"] = area
+        valid.append(entry)
+
+    return valid
+
+
+def pixel_area_to_m2(area_px: float) -> float:
+    return area_px * (2.54 / DPI) ** 2 * (SCALE_FACTOR ** 2) / 10000
+
+
+def run_ocr_on_room(img_bgr: np.ndarray, contour: np.ndarray) -> Optional[str]:
+    try:
+        import easyocr
+        if not hasattr(run_ocr_on_room, "_reader"):
+            run_ocr_on_room._reader = easyocr.Reader(["en"], gpu=False)
+        reader = run_ocr_on_room._reader
+    except ImportError:
+        return None
+
+    x, y, rw, rh = cv2.boundingRect(contour)
+    pad = 20
+    roi = img_bgr[max(0,y-pad):min(img_bgr.shape[0],y+rh+pad),
+                  max(0,x-pad):min(img_bgr.shape[1],x+rw+pad)]
+    if roi.size == 0:
+        return None
+
+    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+    clahe = cv2.createCLAHE(2.0, (8,8))
+    proc  = clahe.apply(gray)
+    _, bin_img = cv2.threshold(proc, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
+    rgb   = cv2.cvtColor(cv2.medianBlur(bin_img, 3), cv2.COLOR_GRAY2RGB)
+
+    try:
+        results = reader.readtext(rgb, detail=1, paragraph=False)
+        cands = [
+            (t.strip().upper(), c)
+            for _, t, c in results
+            if c >= OCR_CONF_THR and len(t.strip()) >= 2 and any(ch.isalpha() for ch in t)
+        ]
+        return max(cands, key=lambda x: x[1])[0] if cands else None
+    except Exception:
+        return None
+
+
+def validate_label(label: str) -> bool:
+    if not label: return False
+    label = label.strip()
+    if not label[0].isalpha(): return False
+    lc = sum(1 for c in label if c.isalpha())
+    return lc == 1 or lc >= 3
+
+
+def build_annotated_image(
+    img_bgr: np.ndarray,
+    rooms: List[Dict],
+    selected_ids: Optional[List[int]] = None,
+) -> np.ndarray:
+    vis = img_bgr.copy()
+    overlay = vis.copy()
+
+    for i, room in enumerate(rooms):
+        color = ROOM_COLORS[i % len(ROOM_COLORS)]
+        bgr   = (color[2], color[1], color[0])
+        cnt   = room.get("contour")
+        if cnt is None: continue
+
+        cv2.drawContours(overlay, [cnt], -1, bgr, -1)
+        alpha = 0.35
+        vis   = cv2.addWeighted(overlay, alpha, vis, 1-alpha, 0)
+        overlay = vis.copy()
+
+        is_sel = selected_ids and room["id"] in selected_ids
+        border_t = 4 if is_sel else 2
+        border_c = (0, 255, 255) if is_sel else bgr
+        cv2.drawContours(vis, [cnt], -1, border_c, border_t)
+
+        M  = cv2.moments(cnt)
+        cx = int(M["m10"]/M["m00"]) if M["m00"] else 0
+        cy = int(M["m01"]/M["m00"]) if M["m00"] else 0
+
+        label  = room.get("label", f"Room {room['id']}")
+        area   = room.get("area_m2", 0.0)
+        text1  = label
+        text2  = f"{area:.1f} m²"
+
+        fs = 0.55
+        th = 1
+        (tw1, th1), _ = cv2.getTextSize(text1, cv2.FONT_HERSHEY_SIMPLEX, fs, th)
+        (tw2, th2), _ = cv2.getTextSize(text2, cv2.FONT_HERSHEY_SIMPLEX, fs-0.1, th)
+
+        bx = cx - max(tw1, tw2)//2 - 4
+        by = cy - th1 - th2 - 12
+        bw2 = max(tw1, tw2) + 8
+        bh2 = th1 + th2 + 16
+
+        sub = vis[max(0,by):max(0,by)+bh2, max(0,bx):max(0,bx)+bw2]
+        if sub.size > 0:
+            white = np.ones_like(sub) * 255
+            vis[max(0,by):max(0,by)+bh2, max(0,bx):max(0,bx)+bw2] = \
+                cv2.addWeighted(sub, 0.3, white, 0.7, 0)
+
+        cv2.putText(vis, text1,
+                    (cx - tw1//2, cy - th2 - 6),
+                    cv2.FONT_HERSHEY_SIMPLEX, fs, (20,20,20), th+1, cv2.LINE_AA)
+        cv2.putText(vis, text2,
+                    (cx - tw2//2, cy + th2 + 2),
+                    cv2.FONT_HERSHEY_SIMPLEX, fs-0.1, (20,20,20), th, cv2.LINE_AA)
+
     return vis
 
 
-# ── Routes ────────────────────────────────────────────────────────────────────
-@app.route("/")
-def index():
-    return render_template_string(HTML_PAGE)
+def export_to_excel(rooms: List[Dict]) -> str:
+    wb = openpyxl.Workbook()
+    ws = wb.active
+    ws.title = "Room Analysis"
+
+    headers = ["ID", "Label", "Area (px)", "Area (m²)", "Centroid X", "Centroid Y",
+               "Bbox X", "Bbox Y", "Bbox W", "Bbox H", "SAM Score", "Confidence"]
+    header_fill = PatternFill("solid", fgColor="1F4E79")
+    header_font = Font(bold=True, color="FFFFFF", size=11)
+
+    for col, h in enumerate(headers, 1):
+        cell = ws.cell(row=1, column=col, value=h)
+        cell.fill = header_fill
+        cell.font = header_font
+        cell.alignment = Alignment(horizontal="center")
+
+    alt_fill = PatternFill("solid", fgColor="D6E4F0")
+    for row_n, room in enumerate(rooms, 2):
+        cnt = room.get("contour")
+        M   = cv2.moments(cnt) if cnt is not None else {}
+        cx  = int(M["m10"]/M["m00"]) if M.get("m00") else 0
+        cy  = int(M["m01"]/M["m00"]) if M.get("m00") else 0
+        bbox = cv2.boundingRect(cnt) if cnt is not None else (0,0,0,0)
+
+        row_data = [
+            room.get("id"), room.get("label","?"),
+            round(room.get("area_px",0),1),
+            round(room.get("area_m2",0.0),2),
+            cx, cy,
+            bbox[0], bbox[1], bbox[2], bbox[3],
+            round(room.get("score",1.0),4),
+            round(room.get("confidence",0.95),2),
+        ]
+        fill = alt_fill if row_n % 2 == 0 else None
+        for col, val in enumerate(row_data, 1):
+            cell = ws.cell(row=row_n, column=col, value=val)
+            cell.alignment = Alignment(horizontal="center")
+            if fill: cell.fill = fill
+
+    for col in ws.columns:
+        max_len = max(len(str(c.value or "")) for c in col) + 4
+        ws.column_dimensions[col[0].column_letter].width = min(max_len, 25)
+
+    out = Path(tempfile.gettempdir()) / f"floorplan_rooms_{int(time.time())}.xlsx"
+    wb.save(str(out))
+    return str(out)
+
+
+# ═════════════��══════════════════════════════════════════════════════════════
+#  STATE  (Gradio state object, passed between callbacks)
+# ════════════════════════════════════════════════════════════════════════════
+
+def init_state() -> Dict:
+    return {
+        "img_orig":     None,   # BGR
+        "img_cropped":  None,
+        "img_clean":    None,
+        "walls":        None,
+        "user_lines":   [],     # [(x1,y1,x2,y2), …]
+        "draw_start":   None,   # pending line start pixel
+        "walls_thickness": 8,
+        "rooms":        [],     # list of room dicts
+        "selected_ids": [],
+        "annotated":    None,   # BGR annotated image
+        "status":       "Idle",
+    }
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  GRADIO CALLBACKS
+# ════════════════════════════════════════════════════════════════════════════
+
+def cb_load_image(upload, state):
+    if upload is None:
+        return None, state, "Upload a floor-plan image to begin."
+    img_bgr = cv2.imdecode(
+        np.frombuffer(upload, dtype=np.uint8), cv2.IMREAD_COLOR
+    )
+    if img_bgr is None:
+        return None, state, "❌ Could not decode image."
+    state = init_state()
+    state["img_orig"] = img_bgr
+    state["status"]   = "Image loaded."
+    preview = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    return preview, state, f"✅ Loaded {img_bgr.shape[1]}×{img_bgr.shape[0]} px"
+
+
+def cb_preprocess(state):
+    img = state.get("img_orig")
+    if img is None:
+        return None, None, state, "Load an image first."
+
+    cropped = remove_title_block(img)
+    clean   = remove_colors(cropped)
+
+    state["img_cropped"] = cropped
+    state["img_clean"]   = clean
+
+    walls, thick = extract_walls_adaptive(clean)
+    state["walls"]           = walls.copy()
+    state["walls_thickness"] = thick
+
+    walls_rgb = cv2.cvtColor(walls, cv2.COLOR_GRAY2RGB)
+    clean_rgb = cv2.cvtColor(clean, cv2.COLOR_BGR2RGB)
+    return clean_rgb, walls_rgb, state, f"✅ Walls extracted  (thickness≈{thick}px)"
+
+
+def cb_add_door_line(evt: gr.SelectData, state):
+    """
+    Two-click line drawing on the wall image.
+    First click → sets start, second click → draws line and resets.
+    """
+    walls = state.get("walls")
+    if walls is None:
+        return None, state, "Run preprocessing first."
+
+    x, y = int(evt.index[0]), int(evt.index[1])
+
+    if state["draw_start"] is None:
+        state["draw_start"] = (x, y)
+        msg = f"🖊 Start point set ({x},{y}). Click end point."
+    else:
+        x1, y1 = state["draw_start"]
+        state["user_lines"].append((x1, y1, x, y))
+        state["draw_start"] = None
+
+        # apply all lines to walls
+        walls_upd = apply_user_lines_to_walls(
+            state["walls"], state["user_lines"], state["walls_thickness"]
+        )
+        state["walls"] = walls_upd
+
+        vis = cv2.cvtColor(walls_upd, cv2.COLOR_GRAY2RGB)
+        for lx1, ly1, lx2, ly2 in state["user_lines"]:
+            cv2.line(vis, (lx1,ly1), (lx2,ly2), (255,80,80), 3)
+        return vis, state, f"✅ Door line drawn ({x1},{y1})→({x},{y})  Total: {len(state['user_lines'])}"
+
+    vis = cv2.cvtColor(walls, cv2.COLOR_GRAY2RGB)
+    for lx1, ly1, lx2, ly2 in state["user_lines"]:
+        cv2.line(vis, (lx1,ly1), (lx2,ly2), (255,80,80), 3)
+    if state["draw_start"]:
+        cv2.circle(vis, state["draw_start"], 6, (0,200,255), -1)
+    return vis, state, msg
+
+
+def cb_undo_door_line(state):
+    if not state["user_lines"]:
+        return None, state, "No lines to undo."
+    state["user_lines"].pop()
+    state["draw_start"] = None
+
+    walls = state.get("walls")
+    img   = state.get("img_clean")
+    if walls is None:
+        return None, state, "Re-run preprocessing."
+
+    # recompute from scratch
+    walls_base, thick = extract_walls_adaptive(state["img_clean"])
+    walls_upd = apply_user_lines_to_walls(
+        walls_base, state["user_lines"], thick
+    )
+    state["walls"] = walls_upd
+
+    vis = cv2.cvtColor(walls_upd, cv2.COLOR_GRAY2RGB)
+    for lx1, ly1, lx2, ly2 in state["user_lines"]:
+        cv2.line(vis, (lx1,ly1), (lx2,ly2), (255,80,80), 3)
+    return vis, state, f"↩ Last line removed. Remaining: {len(state['user_lines'])}"
+
+
+def cb_run_sam(state, progress=gr.Progress()):
+    walls = state.get("walls")
+    img   = state.get("img_cropped")
+    if walls is None or img is None:
+        return None, None, state, "Run preprocessing first."
+
+    progress(0.1, desc="Downloading SAM checkpoint…")
+    ckpt = download_sam_if_needed()
+    if ckpt is None:
+        return None, None, state, "❌ SAM checkpoint download failed."
+
+    progress(0.3, desc="Segmenting rooms…")
+    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    raw     = segment_with_sam(img_rgb, walls.copy(), ckpt)
+
+    progress(0.6, desc="Filtering rooms…")
+    filtered = filter_room_masks(raw, img.shape)
+
+    progress(0.75, desc="Running OCR…")
+    rooms = []
+    for idx, entry in enumerate(filtered, 1):
+        cnt   = entry["contour"]
+        label = run_ocr_on_room(img, cnt)
+        if not label or not validate_label(label):
+            label = f"ROOM {idx}"
+
+        M  = cv2.moments(cnt)
+        cx = int(M["m10"]/M["m00"]) if M["m00"] else 0
+        cy = int(M["m01"]/M["m00"]) if M["m00"] else 0
+        area_px  = entry["area_px"]
+        area_m2  = pixel_area_to_m2(area_px)
+        bx,by,bw,bh = cv2.boundingRect(cnt)
+
+        rooms.append({
+            "id":         idx,
+            "label":      label,
+            "contour":    cnt,
+            "mask":       entry["mask"],
+            "score":      entry["score"],
+            "area_px":    round(area_px, 1),
+            "area_m2":    round(area_m2, 2),
+            "bbox":       [bx, by, bw, bh],
+            "centroid":   [cx, cy],
+            "confidence": 0.95,
+        })
+
+    state["rooms"]       = rooms
+    state["selected_ids"] = []
 
+    progress(0.9, desc="Rendering…")
+    annotated = build_annotated_image(img, rooms)
+    state["annotated"] = annotated
 
-@app.route("/api/session", methods=["POST"])
-def create_session():
-    sid = _new_session()
-    return jsonify({"session_id": sid})
+    table = [[r["id"], r["label"], f"{r['area_m2']} m²", f"{r['score']:.2f}"]
+             for r in rooms]
 
+    ann_rgb = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
+    return ann_rgb, table, state, f"✅ {len(rooms)} rooms detected."
 
-@app.route("/api/upload", methods=["POST"])
-def upload():
-    sid  = request.form.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None:
-        return jsonify({"error": "Invalid session"}), 400
 
-    file  = request.files.get("image")
-    if file is None:
-        return jsonify({"error": "No image"}), 400
+def cb_click_room(evt: gr.SelectData, state):
+    annotated = state.get("annotated")
+    rooms     = state.get("rooms", [])
+    img       = state.get("img_cropped")
+    if annotated is None or not rooms:
+        return None, state, "Run SAM first."
 
-    buf  = np.frombuffer(file.read(), np.uint8)
-    img  = cv2.imdecode(buf, cv2.IMREAD_COLOR)
-    if img is None:
-        return jsonify({"error": "Could not decode image"}), 400
-
-    # Downscale very large images to keep processing fast
-    max_px = 2400
-    h, w   = img.shape[:2]
-    if max(h, w) > max_px:
-        scale = max_px / max(h, w)
-        img   = cv2.resize(img, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_AREA)
-
-    with _sessions_lock:
-        sess["original_bgr"] = img
-        sess["wall_mask"]    = None
-        sess["room_mask"]    = None
-        sess["rooms"]        = []
-        sess["stage_images"] = {}
-        sess["door_lines"]   = []
-        sess["log"]          = []
-        sess["progress"]     = 0
-        sess["status"]       = "uploaded"
-
-    preview = _bgr_to_b64(img)
-    return jsonify({"preview": preview,
-                    "width" : img.shape[1],
-                    "height": img.shape[0]})
-
-
-@app.route("/api/run", methods=["POST"])
-def run_pipeline():
-    data = request.get_json(force=True)
-    sid  = data.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None or sess["original_bgr"] is None:
-        return jsonify({"error": "No image uploaded"}), 400
-
-    def _worker():
-        logs = []
-        def progress(msg, pct):
-            logs.append(msg)
-            with _sessions_lock:
-                sess["log"]      = logs[:]
-                sess["progress"] = pct
-
-        try:
-            with _sessions_lock:
-                sess["status"] = "running"
-
-            pipe = WallPipeline(progress_cb=progress)
-            walls, rooms_mask, cal = pipe.run(
-                sess["original_bgr"],
-                extra_door_lines=sess.get("door_lines", [])
+    x, y = int(evt.index[0]), int(evt.index[1])
+    clicked_id = None
+    for room in rooms:
+        cnt = room.get("contour")
+        if cnt is None: continue
+        if cv2.pointPolygonTest(cnt, (float(x), float(y)), False) >= 0:
+            clicked_id = room["id"]
+            break
+
+    if clicked_id is None:
+        state["selected_ids"] = []
+        msg = "Clicked outside all rooms — selection cleared."
+    else:
+        sel = state["selected_ids"]
+        if clicked_id in sel:
+            sel.remove(clicked_id)
+            msg = f"Room {clicked_id} deselected."
+        else:
+            sel.append(clicked_id)
+            msg = f"Room {clicked_id} selected."
+        state["selected_ids"] = sel
+
+    new_ann = build_annotated_image(img, rooms, state["selected_ids"])
+    state["annotated"] = new_ann
+    return cv2.cvtColor(new_ann, cv2.COLOR_BGR2RGB), state, msg
+
+
+def cb_remove_selected(state):
+    sel   = state.get("selected_ids", [])
+    rooms = state.get("rooms", [])
+    img   = state.get("img_cropped")
+    if not sel:
+        return None, None, state, "No rooms selected."
+
+    removed = [r["label"] for r in rooms if r["id"] in sel]
+    rooms   = [r for r in rooms if r["id"] not in sel]
+    for i, r in enumerate(rooms, 1):
+        r["id"] = i
+    state["rooms"]       = rooms
+    state["selected_ids"] = []
+
+    ann = build_annotated_image(img, rooms)
+    state["annotated"] = ann
+
+    table = [[r["id"], r["label"], f"{r['area_m2']} m²", f"{r['score']:.2f}"]
+             for r in rooms]
+    return cv2.cvtColor(ann, cv2.COLOR_BGR2RGB), table, state, \
+           f"🗑 Removed: {', '.join(removed)}"
+
+
+def cb_rename_selected(new_label, state):
+    sel   = state.get("selected_ids", [])
+    rooms = state.get("rooms", [])
+    img   = state.get("img_cropped")
+    if not sel:
+        return None, None, state, "Select a room first."
+    if not new_label.strip():
+        return None, None, state, "Enter a non-empty label."
+
+    for r in rooms:
+        if r["id"] in sel:
+            r["label"] = new_label.strip().upper()
+    state["rooms"] = rooms
+
+    ann = build_annotated_image(img, rooms, sel)
+    state["annotated"] = ann
+    table = [[r["id"], r["label"], f"{r['area_m2']} m²", f"{r['score']:.2f}"]
+             for r in rooms]
+    return cv2.cvtColor(ann, cv2.COLOR_BGR2RGB), table, state, \
+           f"✏ Renamed to '{new_label.strip().upper()}'"
+
+
+def cb_export_excel(state):
+    rooms = state.get("rooms", [])
+    if not rooms:
+        return None, "No rooms to export."
+    path = export_to_excel(rooms)
+    return path, f"✅ Exported {len(rooms)} rooms → {Path(path).name}"
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  GRADIO UI
+# ════════════════════════════════════════════════════════════════════════════
+
+CSS = """
+#title { text-align: center; font-size: 1.8em; font-weight: 700; color: #1F4E79; }
+#subtitle { text-align: center; color: #555; margin-top: -8px; margin-bottom: 16px; }
+.step-card { border-left: 4px solid #1F4E79 !important; padding-left: 10px !important; }
+#status-box textarea { font-size: 0.95em !important; color: #1a6b2e !important; font-weight: 600 !important; }
+"""
+
+with gr.Blocks(css=CSS, title="FloorPlan Analyser") as app:
+    state = gr.State(init_state())
+
+    gr.Markdown("# 🏢 Floor Plan Room Analyser", elem_id="title")
+    gr.Markdown(
+        "Upload a floor-plan → auto-extract walls → close doors → SAM segmentation → OCR labels → export Excel",
+        elem_id="subtitle"
+    )
+
+    status_box = gr.Textbox(label="Status", interactive=False,
+                            value="Idle — upload a floor plan to begin.",
+                            elem_id="status-box")
+
+    # ── Row 1: Upload + Preprocessing ───────────────────────────────────────
+    with gr.Row():
+        with gr.Column(scale=1, elem_classes="step-card"):
+            gr.Markdown("### 1️⃣  Upload Floor Plan")
+            upload_btn = gr.UploadButton(
+                "📂 Upload Image", file_types=["image"], size="sm"
+            )
+            raw_preview = gr.Image(label="Loaded Image", height=320)
+
+        with gr.Column(scale=1, elem_classes="step-card"):
+            gr.Markdown("### 2️⃣  Pre-process  (Crop → De-color → Walls)")
+            preprocess_btn = gr.Button("⚙ Run Preprocessing", variant="primary")
+            with gr.Tabs():
+                with gr.Tab("Clean Image"):
+                    clean_img = gr.Image(label="After color removal", height=300)
+                with gr.Tab("Walls"):
+                    walls_img = gr.Image(label="Extracted walls", height=300)
+
+    # ── Row 2: Door Line Drawing ─────────────────────────────────────────────
+    with gr.Row():
+        with gr.Column(elem_classes="step-card"):
+            gr.Markdown("### 3️⃣  Draw Door-Closing Lines  *(click start → click end)*")
+            gr.Markdown(
+                "Click on the **Walls** image below to define start/end of a door-closing line. "
+                "Drawn lines are applied to the wall mask before SAM runs, preventing segment leakage."
+            )
+            with gr.Row():
+                undo_line_btn   = gr.Button("↩ Undo Last Line", size="sm")
+            wall_draw_img = gr.Image(
+                label="Wall mask — click to draw door lines",
+                height=380, interactive=False
             )
 
-            # Auto-detect rooms from filtered mask
-            contours, _ = cv2.findContours(
-                rooms_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-            rooms = []
-            for idx, cnt in enumerate(contours, 1):
-                area = cv2.contourArea(cnt)
-                bx, by, bw, bh = cv2.boundingRect(cnt)
-                M  = cv2.moments(cnt)
-                cx = int(M["m10"]/M["m00"]) if M["m00"] else bx+bw//2
-                cy = int(M["m01"]/M["m00"]) if M["m00"] else by+bh//2
-                seg = cnt[:,0,:].tolist()
-                seg = [v for pt in seg for v in pt]
-                rooms.append({
-                    "id"          : idx,
-                    "label"       : f"Room {idx}",
-                    "segmentation": [seg],
-                    "area"        : float(area),
-                    "bbox"        : [bx, by, bw, bh],
-                    "centroid"    : [cx, cy],
-                    "confidence"  : 0.95,
-                    "isAi"        : True,
-                })
-
-            with _sessions_lock:
-                sess["wall_mask"]    = walls
-                sess["room_mask"]    = rooms_mask
-                sess["rooms"]        = rooms
-                sess["stage_images"] = pipe.stage_images
-                sess["calibration"]  = cal.as_dict() if cal else {}
-                sess["status"]       = "done"
-                sess["progress"]     = 100
-
-        except Exception as exc:
-            tb = traceback.format_exc()
-            with _sessions_lock:
-                sess["status"] = "error"
-                sess["log"]    = logs + [f"ERROR: {exc}", tb]
-
-    t = threading.Thread(target=_worker, daemon=True)
-    t.start()
-    return jsonify({"started": True})
-
-
-@app.route("/api/progress", methods=["GET"])
-def progress():
-    sid  = request.args.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None:
-        return jsonify({"error": "Invalid session"}), 400
-    with _sessions_lock:
-        return jsonify({
-            "status"  : sess["status"],
-            "progress": sess["progress"],
-            "log"     : sess["log"][-6:] if sess["log"] else [],
-        })
+    # ── Row 3: SAM + Annotation ──────────────────────────────────────────────
+    with gr.Row():
+        with gr.Column(scale=2, elem_classes="step-card"):
+            gr.Markdown("### 4️⃣  SAM Segmentation + OCR")
+            sam_btn = gr.Button("🤖 Run SAM + OCR", variant="primary")
+            ann_img = gr.Image(
+                label="Annotated rooms — click to select/deselect",
+                height=480, interactive=False
+            )
 
+        with gr.Column(scale=1, elem_classes="step-card"):
+            gr.Markdown("### 5️⃣  Room Table & Actions")
+            room_table = gr.Dataframe(
+                headers=["ID", "Label", "Area", "SAM Score"],
+                datatype=["number", "str", "str", "str"],
+                interactive=False, label="Detected Rooms"
+            )
+            with gr.Group():
+                gr.Markdown("**Edit selected room(s)**")
+                rename_txt = gr.Textbox(
+                    placeholder="New label…", label="Rename Label"
+                )
+                with gr.Row():
+                    rename_btn = gr.Button("✏ Rename", size="sm")
+                    remove_btn = gr.Button("🗑 Remove Selected", size="sm", variant="stop")
+
+            gr.Markdown("---")
+            export_btn  = gr.Button("📊 Export to Excel", variant="secondary")
+            excel_file  = gr.File(label="Download Excel", visible=True)
+
+    # ── Wiring ───────────────────────────────────────────────────────────────
+
+    upload_btn.upload(
+        cb_load_image,
+        inputs=[upload_btn, state],
+        outputs=[raw_preview, state, status_box]
+    )
 
-@app.route("/api/result", methods=["GET"])
-def result():
-    sid  = request.args.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None:
-        return jsonify({"error": "Invalid session"}), 400
-
-    orig  = sess.get("original_bgr")
-    walls = sess.get("wall_mask")
-    rooms = sess.get("rooms", [])
-
-    if orig is None:
-        return jsonify({"error": "No image"}), 400
-
-    composite = _composite_overlay(orig, rooms, walls)
-    return jsonify({
-        "composite"  : _bgr_to_b64(composite),
-        "wall_mask"  : _mask_to_b64(walls) if walls is not None else None,
-        "rooms"      : rooms,
-        "calibration": sess.get("calibration", {}),
-        "gpu"        : _GPU,
-        "gpu_detail" : {
-            "cupy"        : _CUPY,
-            "torch_cuda"  : _TORCH_CUDA,
-            "opencv_cuda" : _CV_CUDA,
-        },
-    })
-
-
-@app.route("/api/stages", methods=["GET"])
-def stages():
-    sid  = request.args.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None:
-        return jsonify({"error": "Invalid session"}), 400
-
-    stage_imgs = sess.get("stage_images", {})
-    result     = {}
-    for key, img in stage_imgs.items():
-        if img is not None and isinstance(img, np.ndarray):
-            if len(img.shape) == 2:
-                disp = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-            else:
-                disp = img
-            result[key] = _bgr_to_b64(disp, max_dim=800)
-    return jsonify(result)
-
-
-@app.route("/api/wand", methods=["POST"])
-def wand():
-    """Click-to-segment: flood-fill from clicked pixel."""
-    data = request.get_json(force=True)
-    sid  = data.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None or sess["wall_mask"] is None:
-        return jsonify({"error": "Run pipeline first"}), 400
-
-    click_x = int(data.get("x", 0))
-    click_y = int(data.get("y", 0))
-
-    pipe    = WallPipeline()
-    new_room = pipe.wand_segment(
-        sess["wall_mask"], click_x, click_y, sess["rooms"]
+    preprocess_btn.click(
+        cb_preprocess,
+        inputs=[state],
+        outputs=[clean_img, walls_img, state, status_box]
+    ).then(
+        lambda s: cv2.cvtColor(s["walls"], cv2.COLOR_GRAY2RGB)
+                  if s.get("walls") is not None else None,
+        inputs=[state],
+        outputs=[wall_draw_img]
     )
-    if new_room is None:
-        return jsonify({"error": "No room found at that location"}), 400
-
-    with _sessions_lock:
-        sess["rooms"].append(new_room)
-
-    orig      = sess["original_bgr"]
-    composite = _composite_overlay(orig, sess["rooms"], sess["wall_mask"])
-    return jsonify({
-        "room"     : new_room,
-        "composite": _bgr_to_b64(composite),
-        "rooms"    : sess["rooms"],
-    })
-
-
-@app.route("/api/remove_room", methods=["POST"])
-def remove_room():
-    data   = request.get_json(force=True)
-    sid    = data.get("session_id", "")
-    room_id = int(data.get("room_id", -1))
-    sess   = _get_session(sid)
-    if sess is None:
-        return jsonify({"error": "Invalid session"}), 400
-
-    with _sessions_lock:
-        before = len(sess["rooms"])
-        sess["rooms"] = [r for r in sess["rooms"] if r["id"] != room_id]
-        removed = before - len(sess["rooms"])
-
-    if removed == 0:
-        return jsonify({"error": f"Room {room_id} not found"}), 404
-
-    orig      = sess["original_bgr"]
-    composite = _composite_overlay(orig, sess["rooms"], sess["wall_mask"])
-    return jsonify({
-        "composite": _bgr_to_b64(composite),
-        "rooms"    : sess["rooms"],
-        "removed"  : room_id,
-    })
-
-
-@app.route("/api/add_door_line", methods=["POST"])
-def add_door_line():
-    data = request.get_json(force=True)
-    sid  = data.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None:
-        return jsonify({"error": "Invalid session"}), 400
-
-    x1 = int(data.get("x1", 0))
-    y1 = int(data.get("y1", 0))
-    x2 = int(data.get("x2", 0))
-    y2 = int(data.get("y2", 0))
-
-    with _sessions_lock:
-        sess["door_lines"].append((x1, y1, x2, y2))
-
-    # If wall mask exists, paint immediately
-    orig  = sess["original_bgr"]
-    walls = sess["wall_mask"]
-    if walls is not None:
-        stroke = sess.get("calibration", {}).get("stroke_width", 3)
-        lw = max(3, stroke)
-        cv2.line(walls, (x1, y1), (x2, y2), 255, lw)
-        # Re-segment rooms
-        pipe = WallPipeline()
-        rooms_mask = pipe._segment_rooms(walls)
-        valid_mask, contours = pipe._filter_rooms(rooms_mask, orig.shape)
-        rooms = []
-        for idx, cnt in enumerate(contours, 1):
-            area = cv2.contourArea(cnt)
-            bx_, by_, bw_, bh_ = cv2.boundingRect(cnt)
-            M  = cv2.moments(cnt)
-            cx = int(M["m10"]/M["m00"]) if M["m00"] else bx_+bw_//2
-            cy = int(M["m01"]/M["m00"]) if M["m00"] else by_+bh_//2
-            seg = cnt[:,0,:].tolist()
-            seg = [v for pt in seg for v in pt]
-            rooms.append({
-                "id": idx, "label": f"Room {idx}",
-                "segmentation": [seg],
-                "area": float(area),
-                "bbox": [bx_, by_, bw_, bh_],
-                "centroid": [cx, cy],
-                "confidence": 0.95,
-            })
-        with _sessions_lock:
-            sess["wall_mask"] = walls
-            sess["room_mask"] = valid_mask
-            sess["rooms"]     = rooms
-
-    composite = _composite_overlay(orig, sess["rooms"], sess["wall_mask"])
-    return jsonify({
-        "composite"  : _bgr_to_b64(composite),
-        "rooms"      : sess["rooms"],
-        "door_lines" : sess["door_lines"],
-    })
-
-
-@app.route("/api/clear_door_lines", methods=["POST"])
-def clear_door_lines():
-    data = request.get_json(force=True)
-    sid  = data.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None:
-        return jsonify({"error": "Invalid session"}), 400
-    with _sessions_lock:
-        sess["door_lines"] = []
-    return jsonify({"cleared": True})
-
-
-@app.route("/api/export", methods=["GET"])
-def export_json():
-    sid  = request.args.get("session_id", "")
-    sess = _get_session(sid)
-    if sess is None:
-        return jsonify({"error": "Invalid session"}), 400
-    rooms = sess.get("rooms", [])
-    safe  = []
-    for r in rooms:
-        safe.append({k: v for k, v in r.items()
-                     if k in ("id","label","area","bbox","centroid","confidence")})
-    return Response(
-        json.dumps({"rooms": safe, "count": len(safe)}, indent=2),
-        mimetype="application/json",
-        headers={"Content-Disposition": "attachment; filename=rooms.json"}
+
+    wall_draw_img.select(
+        cb_add_door_line,
+        inputs=[state],
+        outputs=[wall_draw_img, state, status_box]
     )
 
+    undo_line_btn.click(
+        cb_undo_door_line,
+        inputs=[state],
+        outputs=[wall_draw_img, state, status_box]
+    )
 
-# ─────────────────────────────────────────────────────────────────────────────
-#  HTML / CSS / JS  (single-page app)
-# ─────────────────────────────────────────────────────────────────────────────
-HTML_PAGE = r"""
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8"/>
-<meta name="viewport" content="width=device-width,initial-scale=1"/>
-<title>Blueprint Room Extractor</title>
-<style>
-/* ── Reset & base ── */
-*{box-sizing:border-box;margin:0;padding:0}
-:root{
-  --bg:#0b0c10;--panel:#13151c;--panel2:#1a1d27;--border:#252836;
-  --accent:#00d4aa;--accent2:#6c63ff;--warn:#f59e0b;--danger:#ef4444;
-  --text:#e8eaf0;--muted:#8b90a0;--font:'JetBrains Mono',monospace;
-}
-@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;700&family=Syne:wght@400;600;800&display=swap');
-html,body{height:100%;background:var(--bg);color:var(--text);font-family:var(--font);font-size:13px;overflow:hidden}
-
-/* ── Layout ── */
-#app{display:grid;grid-template-columns:320px 1fr 280px;grid-template-rows:56px 1fr 38px;height:100vh;gap:0}
-header{grid-column:1/-1;background:var(--panel);border-bottom:1px solid var(--border);
-       display:flex;align-items:center;gap:16px;padding:0 20px}
-header h1{font-family:'Syne',sans-serif;font-weight:800;font-size:18px;
-          background:linear-gradient(135deg,var(--accent),var(--accent2));
-          -webkit-background-clip:text;-webkit-text-fill-color:transparent;letter-spacing:-.5px}
-.gpu-badge{padding:3px 10px;border-radius:20px;font-size:10px;font-weight:700;letter-spacing:.8px;
-           background:rgba(108,99,255,.18);color:var(--accent2);border:1px solid var(--accent2)}
-.gpu-badge.on{background:rgba(0,212,170,.18);color:var(--accent);border-color:var(--accent)}
-
-/* ── Left panel ── */
-#left{background:var(--panel);border-right:1px solid var(--border);overflow-y:auto;padding:16px;display:flex;flex-direction:column;gap:14px}
-.section-title{font-family:'Syne',sans-serif;font-size:11px;font-weight:600;color:var(--muted);
-               text-transform:uppercase;letter-spacing:1.2px;padding-bottom:6px;border-bottom:1px solid var(--border)}
-
-/* ── Upload zone ── */
-#drop-zone{border:2px dashed var(--border);border-radius:10px;padding:24px 16px;text-align:center;
-           cursor:pointer;transition:all .2s;color:var(--muted);position:relative}
-#drop-zone:hover,#drop-zone.over{border-color:var(--accent);color:var(--accent);background:rgba(0,212,170,.04)}
-#drop-zone input{position:absolute;inset:0;opacity:0;cursor:pointer}
-#drop-zone .icon{font-size:28px;margin-bottom:6px}
-#drop-zone p{font-size:11px}
-
-/* ── Buttons ── */
-.btn{display:flex;align-items:center;gap:6px;padding:9px 14px;border-radius:8px;border:none;cursor:pointer;
-     font-family:var(--font);font-size:12px;font-weight:500;transition:all .15s;width:100%;justify-content:center}
-.btn-primary{background:linear-gradient(135deg,var(--accent),#00b890);color:#001a14}
-.btn-primary:hover{opacity:.9;transform:translateY(-1px)}
-.btn-secondary{background:var(--panel2);color:var(--text);border:1px solid var(--border)}
-.btn-secondary:hover{border-color:var(--accent);color:var(--accent)}
-.btn-danger{background:rgba(239,68,68,.15);color:var(--danger);border:1px solid rgba(239,68,68,.3)}
-.btn-danger:hover{background:rgba(239,68,68,.25)}
-.btn-warn{background:rgba(245,158,11,.13);color:var(--warn);border:1px solid rgba(245,158,11,.3)}
-.btn-warn:hover{background:rgba(245,158,11,.22)}
-.btn:disabled{opacity:.4;cursor:not-allowed;transform:none!important}
-
-/* ── Tool panel ── */
-.tool-group{display:flex;flex-direction:column;gap:8px}
-.tool-row{display:flex;gap:7px}
-.tool-btn{flex:1;padding:8px 6px;border-radius:7px;border:1px solid var(--border);background:var(--panel2);
-          color:var(--muted);cursor:pointer;font-size:18px;transition:all .15s;font-family:var(--font)}
-.tool-btn:hover{border-color:var(--accent);color:var(--accent)}
-.tool-btn.active{border-color:var(--accent);background:rgba(0,212,170,.12);color:var(--accent)}
-.tool-label{font-size:10px;color:var(--muted);text-align:center;margin-top:2px}
-
-/* ── Inputs ── */
-.field{display:flex;flex-direction:column;gap:5px}
-.field label{font-size:10px;color:var(--muted);text-transform:uppercase;letter-spacing:.8px}
-.field input{background:var(--panel2);border:1px solid var(--border);border-radius:6px;
-             color:var(--text);font-family:var(--font);font-size:12px;padding:7px 10px;width:100%}
-.field input:focus{outline:none;border-color:var(--accent)}
-.coord-row{display:grid;grid-template-columns:1fr 1fr 1fr 1fr;gap:5px}
-.coord-row input{text-align:center}
-
-/* ── Progress ── */
-#progress-bar-wrap{height:4px;background:var(--panel2);border-radius:2px;overflow:hidden;margin-top:4px}
-#progress-bar{height:100%;width:0%;background:linear-gradient(90deg,var(--accent),var(--accent2));transition:width .4s}
-#status-text{font-size:11px;color:var(--muted)}
-
-/* ── Center canvas area ── */
-#center{background:var(--bg);overflow:hidden;position:relative;display:flex;flex-direction:column}
-#viewer-toolbar{background:var(--panel);border-bottom:1px solid var(--border);
-                padding:8px 14px;display:flex;align-items:center;gap:10px;flex-shrink:0}
-.zoom-ctrl{display:flex;align-items:center;gap:6px}
-.zoom-ctrl label{font-size:11px;color:var(--muted);min-width:38px}
-.zoom-ctrl input[type=range]{width:90px;accent-color:var(--accent)}
-.zoom-val{font-size:11px;color:var(--accent);min-width:38px}
-#canvas-wrap{flex:1;overflow:auto;display:flex;align-items:center;justify-content:center;position:relative}
-#img-layer{position:relative;transform-origin:top left;display:inline-block;line-height:0}
-#img-layer img{display:block;max-width:none;cursor:crosshair;user-select:none}
-#img-layer canvas{position:absolute;top:0;left:0;pointer-events:none}
-.crosshair-cursor{cursor:crosshair!important}
-.default-cursor{cursor:default!important}
-
-/* ── Tab view (stages) ── */
-#tabs{display:flex;gap:1px;background:var(--bg);padding:0 14px}
-.tab{padding:8px 14px;font-size:11px;cursor:pointer;color:var(--muted);border-bottom:2px solid transparent;transition:all .15s}
-.tab:hover{color:var(--text)}
-.tab.active{color:var(--accent);border-bottom-color:var(--accent)}
-
-/* ── Right panel ── */
-#right{background:var(--panel);border-left:1px solid var(--border);overflow-y:auto;padding:14px;display:flex;flex-direction:column;gap:12px}
-#rooms-list{display:flex;flex-direction:column;gap:6px}
-.room-card{background:var(--panel2);border:1px solid var(--border);border-radius:8px;padding:10px 12px;
-           display:flex;align-items:center;gap:8px;transition:border-color .15s}
-.room-card:hover{border-color:var(--accent)}
-.room-dot{width:10px;height:10px;border-radius:50%;flex-shrink:0}
-.room-info{flex:1;min-width:0}
-.room-name{font-size:12px;font-weight:500;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.room-meta{font-size:10px;color:var(--muted)}
-.room-del{background:none;border:none;color:var(--muted);cursor:pointer;font-size:14px;padding:2px 5px;
-          border-radius:4px;transition:all .15s}
-.room-del:hover{color:var(--danger);background:rgba(239,68,68,.1)}
-
-/* ── Calibration display ── */
-.cal-grid{display:grid;grid-template-columns:1fr 1fr;gap:5px}
-.cal-item{background:var(--panel2);border-radius:6px;padding:7px 10px}
-.cal-key{font-size:9px;color:var(--muted);text-transform:uppercase;letter-spacing:.7px}
-.cal-val{font-size:13px;font-weight:500;color:var(--accent);margin-top:2px}
-
-/* ── Log ── */
-#log-box{background:var(--panel2);border-radius:8px;padding:10px;font-size:10px;color:var(--muted);
-         max-height:130px;overflow-y:auto;line-height:1.6}
-
-/* ── Status bar ── */
-footer{grid-column:1/-1;background:var(--panel);border-top:1px solid var(--border);
-       padding:0 16px;display:flex;align-items:center;gap:16px;font-size:10px;color:var(--muted)}
-footer span{display:flex;align-items:center;gap:5px}
-.dot{width:7px;height:7px;border-radius:50%;background:var(--muted)}
-.dot.green{background:var(--accent)}
-.dot.orange{background:var(--warn);animation:pulse .8s infinite}
-.dot.red{background:var(--danger)}
-@keyframes pulse{0%,100%{opacity:1}50%{opacity:.3}}
-
-/* ── Stage grid ── */
-#stages-grid{display:grid;grid-template-columns:1fr 1fr;gap:8px;padding:10px}
-.stage-card{background:var(--panel2);border:1px solid var(--border);border-radius:8px;overflow:hidden}
-.stage-card img{width:100%;display:block}
-.stage-card-label{padding:4px 8px;font-size:10px;color:var(--muted)}
-
-/* ── Divider ── */
-.divider{height:1px;background:var(--border);margin:2px 0}
-
-/* ── Toast ── */
-#toast{position:fixed;bottom:50px;left:50%;transform:translateX(-50%) translateY(20px);
-       background:var(--panel);border:1px solid var(--border);border-radius:10px;
-       padding:10px 20px;font-size:12px;opacity:0;transition:all .3s;pointer-events:none;z-index:999}
-#toast.show{opacity:1;transform:translateX(-50%) translateY(0)}
-#toast.err{border-color:var(--danger);color:var(--danger)}
-#toast.ok{border-color:var(--accent);color:var(--accent)}
-</style>
-</head>
-<body>
-<div id="app">
-
-<!-- HEADER -->
-<header>
-  <div>🏗️</div>
-  <h1>Blueprint Room Extractor</h1>
-  <div class="gpu-badge" id="gpu-badge">CPU</div>
-  <div style="flex:1"></div>
-  <button class="btn btn-secondary" style="width:auto" onclick="exportJSON()">⬇ Export JSON</button>
-</header>
-
-<!-- LEFT PANEL -->
-<div id="left">
-
-  <div class="section-title">Image</div>
-  <div id="drop-zone">
-    <input type="file" id="file-input" accept="image/*" onchange="handleFile(this.files[0])"/>
-    <div class="icon">🖼️</div>
-    <p>Drop blueprint or click to upload</p>
-  </div>
-
-  <button class="btn btn-primary" id="run-btn" disabled onclick="runPipeline()">
-    ⚡ Run Wall Extraction
-  </button>
-
-  <div id="progress-bar-wrap"><div id="progress-bar"></div></div>
-  <div id="status-text">Idle</div>
-
-  <div class="divider"></div>
-  <div class="section-title">Tools</div>
-
-  <div class="tool-group">
-    <div class="tool-row">
-      <div style="flex:1;text-align:center">
-        <button class="tool-btn" id="tool-pan" onclick="setTool('pan')" title="Pan / Zoom">🔍</button>
-        <div class="tool-label">Pan/Zoom</div>
-      </div>
-      <div style="flex:1;text-align:center">
-        <button class="tool-btn active" id="tool-wand" onclick="setTool('wand')" title="Magic Wand">🪄</button>
-        <div class="tool-label">Wand</div>
-      </div>
-      <div style="flex:1;text-align:center">
-        <button class="tool-btn" id="tool-door" onclick="setTool('door')" title="Door Seal">🚪</button>
-        <div class="tool-label">Door Line</div>
-      </div>
-    </div>
-    <div id="tool-hint" style="font-size:10px;color:var(--muted);text-align:center;padding:4px 0">
-      Wand: click image to detect room
-    </div>
-  </div>
-
-  <div class="divider"></div>
-
-  <!-- DOOR LINE manual entry -->
-  <div class="section-title">🚪 Door Seal Line</div>
-  <div style="font-size:10px;color:var(--muted);margin-bottom:4px">Enter pixel coords or click on image with Door tool</div>
-  <div class="coord-row">
-    <div class="field"><label>X1</label><input id="dl-x1" type="number" value="0" min="0"/></div>
-    <div class="field"><label>Y1</label><input id="dl-y1" type="number" value="0" min="0"/></div>
-    <div class="field"><label>X2</label><input id="dl-x2" type="number" value="100" min="0"/></div>
-    <div class="field"><label>Y2</label><input id="dl-y2" type="number" value="0" min="0"/></div>
-  </div>
-  <button class="btn btn-warn" onclick="addDoorLine()">🚪 Add Door Seal Line</button>
-  <button class="btn btn-secondary" onclick="clearDoorLines()" style="font-size:11px">Clear All Door Lines</button>
-  <div id="door-lines-list" style="font-size:10px;color:var(--muted)"></div>
-
-  <div class="divider"></div>
-
-  <!-- REMOVE ROOM -->
-  <div class="section-title">🗑️ Remove Room</div>
-  <div style="display:flex;gap:6px">
-    <div class="field" style="flex:1"><label>Room ID</label><input id="remove-id" type="number" min="1" value="1"/></div>
-    <button class="btn btn-danger" style="width:auto;margin-top:16px;padding:8px 12px" onclick="removeRoom()">Del</button>
-  </div>
-
-</div>
-
-<!-- CENTER: canvas + tab strip -->
-<div id="center">
-  <div id="viewer-toolbar">
-    <div class="zoom-ctrl">
-      <label>Zoom</label>
-      <input type="range" id="zoom-slider" min="20" max="500" value="100" oninput="applyZoom(this.value)"/>
-      <span class="zoom-val" id="zoom-val">100%</span>
-    </div>
-    <div class="zoom-ctrl">
-      <label>Pan X</label>
-      <input type="range" id="pan-x" min="-2000" max="2000" value="0" oninput="applyPan()"/>
-    </div>
-    <div class="zoom-ctrl">
-      <label>Pan Y</label>
-      <input type="range" id="pan-y" min="-2000" max="2000" value="0" oninput="applyPan()"/>
-    </div>
-    <button class="btn btn-secondary" style="width:auto;padding:5px 12px;font-size:11px" onclick="resetView()">⌂ Reset</button>
-    <div id="tabs" style="flex:1;display:flex;justify-content:flex-end">
-      <div class="tab active" onclick="switchTab('result')">Result</div>
-      <div class="tab" onclick="switchTab('walls')">Walls</div>
-      <div class="tab" onclick="switchTab('stages')">Stages</div>
-    </div>
-  </div>
-  <div id="canvas-wrap">
-    <!-- Result tab -->
-    <div id="tab-result" style="position:relative;width:100%;height:100%;display:flex;align-items:center;justify-content:center">
-      <div id="img-layer">
-        <img id="main-img" src="" alt="" style="display:none" onclick="onCanvasClick(event)"/>
-        <canvas id="overlay-canvas"></canvas>
-      </div>
-    </div>
-    <!-- Walls tab -->
-    <div id="tab-walls" style="display:none;width:100%;height:100%;align-items:center;justify-content:center">
-      <img id="walls-img" src="" style="max-width:100%;max-height:100%;border-radius:6px"/>
-    </div>
-    <!-- Stages tab -->
-    <div id="tab-stages" style="display:none;overflow-y:auto;width:100%;height:100%">
-      <div id="stages-grid"></div>
-    </div>
-  </div>
-</div>
-
-<!-- RIGHT PANEL -->
-<div id="right">
-  <div class="section-title">Rooms (<span id="room-count">0</span>)</div>
-  <div id="rooms-list"><div style="color:var(--muted);font-size:11px;text-align:center;padding:20px 0">Run pipeline to detect rooms</div></div>
-
-  <div class="divider"></div>
-  <div class="section-title">Calibration</div>
-  <div class="cal-grid" id="cal-grid">
-    <div style="color:var(--muted);font-size:11px;grid-column:1/-1">—</div>
-  </div>
-
-  <div class="divider"></div>
-  <div class="section-title">Log</div>
-  <div id="log-box">Ready.</div>
-</div>
-
-<!-- FOOTER -->
-<footer>
-  <span><div class="dot" id="status-dot"></div><span id="footer-status">Idle</span></span>
-  <span id="footer-coords" style="font-family:monospace">x:— y:—</span>
-  <span style="margin-left:auto" id="footer-rooms">0 rooms</span>
-</footer>
-
-</div><!-- #app -->
-
-<div id="toast"></div>
-
-<script>
-// ── State ──────────────────────────────────────────────────────────────────
-let SID = null;
-let activeTool = 'wand';
-let zoomLevel  = 100;
-let imgW = 0, imgH = 0;
-let doorStart = null;
-let pollingTimer = null;
-let doorLines = [];
-
-const ROOM_COLORS = ['#00d4aa','#6c63ff','#f59e0b','#ef4444','#10b981',
-                     '#3b82f6','#ec4899','#8b5cf6','#14b8a6','#f97316'];
-
-// ── Init ────────────────────────────────────────────────────────────────────
-async function init(){
-  const r = await fetch('/api/session',{method:'POST'});
-  const d = await r.json();
-  SID = d.session_id;
-}
-init();
-
-// ── File handling ─────────────────────────────────────────────────────────
-const dz = document.getElementById('drop-zone');
-dz.addEventListener('dragover', e=>{e.preventDefault();dz.classList.add('over')});
-dz.addEventListener('dragleave', ()=>dz.classList.remove('over'));
-dz.addEventListener('drop', e=>{e.preventDefault();dz.classList.remove('over');
-  if(e.dataTransfer.files[0]) handleFile(e.dataTransfer.files[0])});
-
-async function handleFile(file){
-  if(!file||!SID) return;
-  const fd = new FormData();
-  fd.append('session_id', SID);
-  fd.append('image', file);
-  setStatus('Uploading...','orange');
-  const r = await fetch('/api/upload',{method:'POST',body:fd});
-  const d = await r.json();
-  if(d.error){toast(d.error,true);return;}
-  imgW = d.width; imgH = d.height;
-  showMainImg('data:image/jpeg;base64,'+d.preview);
-  document.getElementById('run-btn').disabled = false;
-  setStatus('Image loaded','green');
-  toast('Image loaded ✓');
-}
-
-// ── Pipeline ──────────────────────────────────────────────────────────────
-async function runPipeline(){
-  if(!SID) return;
-  document.getElementById('run-btn').disabled = true;
-  setStatus('Running...','orange');
-  setLog(['Starting wall extraction pipeline...']);
-  setProgress(0);
-
-  const r = await fetch('/api/run',{method:'POST',
-    headers:{'Content-Type':'application/json'},
-    body:JSON.stringify({session_id:SID})});
-  const d = await r.json();
-  if(d.error){toast(d.error,true);document.getElementById('run-btn').disabled=false;return;}
-
-  pollingTimer = setInterval(pollProgress, 700);
-}
-
-async function pollProgress(){
-  const r = await fetch('/api/progress?session_id='+SID);
-  const d = await r.json();
-  setProgress(d.progress||0);
-  if(d.log) setLog(d.log);
-  setStatus(d.status==='running'?'Processing…':d.status, d.status==='error'?'red':d.status==='done'?'green':'orange');
-  if(d.status==='done'||d.status==='error'){
-    clearInterval(pollingTimer);
-    if(d.status==='done') loadResult();
-    document.getElementById('run-btn').disabled = false;
-  }
-}
-
-async function loadResult(){
-  const r = await fetch('/api/result?session_id='+SID);
-  const d = await r.json();
-  if(d.error){toast(d.error,true);return;}
-
-  // GPU badge
-  const badge = document.getElementById('gpu-badge');
-  const gd = d.gpu_detail || {};
-  const layers = [];
-  if (gd.cupy)         layers.push('CuPy');
-  if (gd.torch_cuda)   layers.push('Torch');
-  if (gd.opencv_cuda)  layers.push('cv2');
-  if (layers.length) {
-    badge.textContent = '⚡ GPU: ' + layers.join('+');
-    badge.className   = 'gpu-badge on';
-  } else {
-    badge.textContent = 'CPU only';
-    badge.className   = 'gpu-badge';
-  }
-
-  showMainImg('data:image/jpeg;base64,'+d.composite);
-  if(d.wall_mask) document.getElementById('walls-img').src='data:image/jpeg;base64,'+d.wall_mask;
-  updateRooms(d.rooms||[]);
-  updateCalibration(d.calibration||{});
-  loadStages();
-  toast(`✓ Detected ${(d.rooms||[]).length} rooms`,'ok');
-}
-
-async function loadStages(){
-  const r = await fetch('/api/stages?session_id='+SID);
-  const d = await r.json();
-  const grid = document.getElementById('stages-grid');
-  grid.innerHTML='';
-  const labels = {
-    '01_title_removed':'1. Title Block Removed',
-    '02_colors_removed':'2. Colors Removed',
-    '03_door_arcs':'3. Door Arcs Closed',
-    '04_walls_raw':'4. Walls Extracted',
-    '05b_no_fixtures':'5b. Fixtures Removed',
-    '05c_thin_removed':'5c. Thin Lines Removed',
-    '05d_bridged':'5d. Endpoints Bridged',
-    '05e_doors_closed':'5e. Door Openings Closed',
-    '05f_dangling_removed':'5f. Dangling Lines Removed',
-    '05g_large_gaps':'5g. Large Gaps Sealed',
-    '07_rooms':'7. Room Segmentation',
-    '08_rooms_filtered':'8. Filtered Rooms',
-  };
-  for(const [key, b64] of Object.entries(d)){
-    const card = document.createElement('div');
-    card.className='stage-card';
-    card.innerHTML=`<img src="data:image/jpeg;base64,${b64}"/>
-      <div class="stage-card-label">${labels[key]||key}</div>`;
-    grid.appendChild(card);
-  }
-}
-
-// ── Wand tool ─────────────────────────────────────────────────────────────
-async function onCanvasClick(e){
-  const img = document.getElementById('main-img');
-  if(!img.src||img.src==='') return;
-
-  const rect = img.getBoundingClientRect();
-  const scaleX = imgW / (rect.width  * (zoomLevel/100));
-  const scaleY = imgH / (rect.height * (zoomLevel/100));
-  const rawX = (e.clientX - rect.left) * scaleX;
-  const rawY = (e.clientY - rect.top)  * scaleY;
-  const px = Math.round(rawX / (zoomLevel/100));
-  const py = Math.round(rawY / (zoomLevel/100));
-
-  if(activeTool==='wand'){
-    await doWand(Math.round(rawX), Math.round(rawY));
-  } else if(activeTool==='door'){
-    await doDoorClick(Math.round(rawX), Math.round(rawY));
-  }
-}
-
-function getImgCoords(e){
-  const img = document.getElementById('main-img');
-  const rect = img.getBoundingClientRect();
-  // account for CSS zoom transform
-  const zoom = zoomLevel/100;
-  const x = Math.round((e.clientX - rect.left) / zoom);
-  const y = Math.round((e.clientY - rect.top)  / zoom);
-  return {x,y};
-}
-
-function onImgMouseMove(e){
-  const {x,y} = getImgCoords(e);
-  document.getElementById('footer-coords').textContent=`x:${x} y:${y}`;
-}
-
-async function doWand(x,y){
-  if(!SID){toast('Run pipeline first',true);return;}
-  toast('🪄 Detecting room...');
-  const r = await fetch('/api/wand',{method:'POST',
-    headers:{'Content-Type':'application/json'},
-    body:JSON.stringify({session_id:SID,x,y})});
-  const d = await r.json();
-  if(d.error){toast(d.error,true);return;}
-  showMainImg('data:image/jpeg;base64,'+d.composite);
-  updateRooms(d.rooms||[]);
-  toast(`✓ Added Room ${d.room.id}`);
-}
-
-// ── Door line tool ─────────────────────────────────────────────────────────
-async function doDoorClick(x,y){
-  if(doorStart===null){
-    doorStart = {x,y};
-    document.getElementById('dl-x1').value=x;
-    document.getElementById('dl-y1').value=y;
-    toast(`Door start: (${x},${y}) — click end point`);
-  } else {
-    document.getElementById('dl-x2').value=x;
-    document.getElementById('dl-y2').value=y;
-    doorStart = null;
-    await addDoorLine();
-  }
-}
-
-async function addDoorLine(){
-  if(!SID) return;
-  const x1=+document.getElementById('dl-x1').value;
-  const y1=+document.getElementById('dl-y1').value;
-  const x2=+document.getElementById('dl-x2').value;
-  const y2=+document.getElementById('dl-y2').value;
-  const r = await fetch('/api/add_door_line',{method:'POST',
-    headers:{'Content-Type':'application/json'},
-    body:JSON.stringify({session_id:SID,x1,y1,x2,y2})});
-  const d = await r.json();
-  if(d.error){toast(d.error,true);return;}
-  doorLines = d.door_lines||[];
-  renderDoorLinesList();
-  showMainImg('data:image/jpeg;base64,'+d.composite);
-  updateRooms(d.rooms||[]);
-  toast(`✓ Door seal line added`);
-}
-
-async function clearDoorLines(){
-  if(!SID) return;
-  await fetch('/api/clear_door_lines',{method:'POST',
-    headers:{'Content-Type':'application/json'},
-    body:JSON.stringify({session_id:SID})});
-  doorLines=[];
-  renderDoorLinesList();
-  toast('Door lines cleared');
-}
-
-function renderDoorLinesList(){
-  const el = document.getElementById('door-lines-list');
-  if(!doorLines.length){el.textContent='No door lines';return;}
-  el.innerHTML=doorLines.map((l,i)=>
-    `<div style="padding:2px 0;border-bottom:1px solid var(--border)">#${i+1}: (${l[0]},${l[1]})→(${l[2]},${l[3]})</div>`
-  ).join('');
-}
-
-// ── Remove room ───────────────────────────────────────────────────────────
-async function removeRoom(){
-  const id = +document.getElementById('remove-id').value;
-  if(!SID||!id) return;
-  const r = await fetch('/api/remove_room',{method:'POST',
-    headers:{'Content-Type':'application/json'},
-    body:JSON.stringify({session_id:SID,room_id:id})});
-  const d = await r.json();
-  if(d.error){toast(d.error,true);return;}
-  showMainImg('data:image/jpeg;base64,'+d.composite);
-  updateRooms(d.rooms||[]);
-  toast(`✓ Room ${id} removed`);
-}
-
-// ── View helpers ──────────────────────────────────────────────────────────
-function showMainImg(src){
-  const img = document.getElementById('main-img');
-  img.src=src;
-  img.style.display='block';
-  img.onmousemove = onImgMouseMove;
-  img.onclick = onCanvasClick;
-}
-
-function applyZoom(v){
-  zoomLevel = +v;
-  document.getElementById('zoom-val').textContent=v+'%';
-  const layer = document.getElementById('img-layer');
-  const panX  = document.getElementById('pan-x').value;
-  const panY  = document.getElementById('pan-y').value;
-  layer.style.transform=`scale(${v/100}) translate(${panX}px,${panY}px)`;
-}
-
-function applyPan(){
-  applyZoom(zoomLevel);
-}
-
-function resetView(){
-  zoomLevel=100;
-  document.getElementById('zoom-slider').value=100;
-  document.getElementById('pan-x').value=0;
-  document.getElementById('pan-y').value=0;
-  applyZoom(100);
-}
-
-function setTool(t){
-  activeTool=t;
-  document.querySelectorAll('.tool-btn').forEach(b=>b.classList.remove('active'));
-  document.getElementById('tool-'+t).classList.add('active');
-  const hints = {
-    pan:'Pan/Zoom: use sliders above the canvas',
-    wand:'Wand: click image to detect & add a room',
-    door:'Door: click two points to draw a seal line'
-  };
-  document.getElementById('tool-hint').textContent=hints[t];
-  doorStart=null;
-}
-
-function switchTab(name){
-  document.querySelectorAll('.tab').forEach(t=>t.classList.remove('active'));
-  event.target.classList.add('active');
-  document.getElementById('tab-result').style.display=name==='result'?'flex':'none';
-  document.getElementById('tab-walls').style.display =name==='walls' ?'flex':'none';
-  document.getElementById('tab-stages').style.display=name==='stages'?'block':'none';
-}
-
-// ── Room list ─────────────────────────────────────────────────────────────
-function updateRooms(rooms){
-  const list = document.getElementById('rooms-list');
-  document.getElementById('room-count').textContent=rooms.length;
-  document.getElementById('footer-rooms').textContent=rooms.length+' rooms';
-  if(!rooms.length){
-    list.innerHTML='<div style="color:var(--muted);font-size:11px;text-align:center;padding:12px">No rooms detected</div>';
-    return;
-  }
-  list.innerHTML=rooms.map((r,i)=>{
-    const col=ROOM_COLORS[i%ROOM_COLORS.length];
-    const areaPx=Math.round(r.area||0);
-    return `<div class="room-card">
-      <div class="room-dot" style="background:${col}"></div>
-      <div class="room-info">
-        <div class="room-name">#${r.id} ${r.label||''}</div>
-        <div class="room-meta">${areaPx.toLocaleString()} px² · [${(r.bbox||[]).join(',')}]</div>
-      </div>
-      <button class="room-del" title="Delete room" onclick="quickDelete(${r.id})">✕</button>
-    </div>`;
-  }).join('');
-}
-
-async function quickDelete(id){
-  document.getElementById('remove-id').value=id;
-  await removeRoom();
-}
-
-// ── Calibration ───────────────────────────────────────────────────────────
-function updateCalibration(cal){
-  const grid = document.getElementById('cal-grid');
-  const entries=[
-    ['Stroke','stroke_width','px'],
-    ['Bridge gap','bridge_max_gap','px'],
-    ['Door gap','door_gap','px'],
-    ['Min dim','min_component_dim','px'],
-  ];
-  grid.innerHTML=entries.map(([label,key,unit])=>`
-    <div class="cal-item">
-      <div class="cal-key">${label}</div>
-      <div class="cal-val">${cal[key]??'—'}${cal[key]!==undefined?unit:''}</div>
-    </div>`).join('');
-}
-
-// ── Misc ─────────────────────────────────────────────────────────────────
-function setProgress(pct){
-  document.getElementById('progress-bar').style.width=pct+'%';
-  document.getElementById('status-text').textContent=pct+'%';
-}
-
-function setLog(lines){
-  const el=document.getElementById('log-box');
-  el.innerHTML=lines.map(l=>`<div>${l}</div>`).join('');
-  el.scrollTop=el.scrollHeight;
-}
-
-function setStatus(msg,color=''){
-  document.getElementById('footer-status').textContent=msg;
-  const dot=document.getElementById('status-dot');
-  dot.className='dot'+(color?' '+color:'');
-}
-
-function toast(msg,err=false){
-  const t=document.getElementById('toast');
-  t.textContent=msg;
-  t.className='show'+(err?' err':' ok');
-  clearTimeout(t._tid);
-  t._tid=setTimeout(()=>{t.className=''},2800);
-}
-
-async function exportJSON(){
-  if(!SID) return;
-  window.location='/api/export?session_id='+SID;
-}
-</script>
-</body>
-</html>
-"""
+    sam_btn.click(
+        cb_run_sam,
+        inputs=[state],
+        outputs=[ann_img, room_table, state, status_box]
+    )
+
+    ann_img.select(
+        cb_click_room,
+        inputs=[state],
+        outputs=[ann_img, state, status_box]
+    )
+
+    remove_btn.click(
+        cb_remove_selected,
+        inputs=[state],
+        outputs=[ann_img, room_table, state, status_box]
+    )
+
+    rename_btn.click(
+        cb_rename_selected,
+        inputs=[rename_txt, state],
+        outputs=[ann_img, room_table, state, status_box]
+    )
+
+    export_btn.click(
+        cb_export_excel,
+        inputs=[state],
+        outputs=[excel_file, status_box]
+    )
 
 if __name__ == "__main__":
-    print("=" * 60)
-    print(" Blueprint Room Extractor")
-    print(f" GPU: CuPy={_CUPY}  PyTorch-CUDA={_TORCH_CUDA}  OpenCV-CUDA={_CV_CUDA}")
-    print(" Open: http://localhost:7860")
-    print("=" * 60)
-    app.run(host="0.0.0.0", port=7860, debug=False, threaded=True)
+    app.launch(share=False, debug=True)