Update app.py

app.py

@@ -1,21 +1,17 @@
 """
-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
+FloorPlan Analyser — Gradio Application  (NVIDIA CUDA-Optimised Build)
+=======================================================================
+GPU improvements over baseline:
+  • EasyOCR        : gpu=True  (was hardcoded gpu=False)
+  • SAM inference  : batched predict_batch() under torch.no_grad() +
+                     torch.autocast("cuda") for FP16 speed-up
+  • OpenCV         : cv2.cuda.* used for GaussianBlur, threshold,
+                     morphologyEx, dilate wherever CUDA mat is valid
+  • Heavy NumPy    : CuPy (cp.*) used for distance/angle arrays in
+                     _bridge_wall_endpoints_v2 and close_large_door_gaps
+  • Memory mgmt    : torch.cuda.empty_cache() after SAM; pin_memory
+                     transfers; torch.no_grad() guard throughout
+  • cv2.cuda stream: single persistent CUDA stream for all cv2.cuda ops
 """
 
 from __future__ import annotations
@@ -30,17 +26,35 @@ 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"
+# ── GPU availability flags ───────────────────────────────────────────────────
+try:
+    import torch
+    _TORCH_CUDA = torch.cuda.is_available()
+except ImportError:
+    _TORCH_CUDA = False
+
+try:
+    import cupy as cp
+    _CUPY = True
+except ImportError:
+    _CUPY = False
+    cp = None                           # type: ignore
+
+# Persistent CUDA stream for cv2.cuda ops (avoids per-call stream creation)
+_CV2_CUDA = cv2.cuda.getCudaEnabledDeviceCount() > 0
+_CUDA_STREAM: Optional[cv2.cuda.Stream] = cv2.cuda.Stream() if _CV2_CUDA else None  # type: ignore
+
+print(f"[GPU] torch_cuda={_TORCH_CUDA}  cupy={_CUPY}  cv2_cuda={_CV2_CUDA}")
+
+# ─── SAM HuggingFace endpoint ────────────────────────────────────────────────
+HF_REPO  = "Pream912/sam"
+HF_API   = f"https://huggingface.co/{HF_REPO}/resolve/main"
+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
+SCALE_FACTOR = 100
 
-# ─── constants (ported from GeometryAgent) ──────────────────────────────────
 MIN_ROOM_AREA_FRAC = 0.000004
 MAX_ROOM_AREA_FRAC = 0.08
 MIN_ROOM_DIM_FRAC  = 0.01
@@ -62,6 +76,61 @@ ROOM_COLORS = [
     (176, 224, 230),
 ]
 
+
+# ════════════════════════════════════════════════════════════════════════════
+#  GPU-ACCELERATED OpenCV HELPERS
+# ════════════════════════════════════════════════════════════════════════════
+
+def _cuda_upload(img: np.ndarray) -> "cv2.cuda.GpuMat":
+    """Upload a numpy array to GPU memory."""
+    gm = cv2.cuda_GpuMat()
+    gm.upload(img, stream=_CUDA_STREAM)
+    return gm
+
+
+def _cuda_gaussian_blur(gray: np.ndarray, ksize: Tuple[int,int], sigma: float) -> np.ndarray:
+    """GaussianBlur on GPU when available, CPU fallback."""
+    if _CV2_CUDA:
+        g_gpu = _cuda_upload(gray)
+        filt  = cv2.cuda.createGaussianFilter(
+            cv2.CV_8UC1, cv2.CV_8UC1, ksize, sigma
+        )
+        out = filt.apply(g_gpu, stream=_CUDA_STREAM)
+        return out.download()
+    return cv2.GaussianBlur(gray, ksize, sigma)
+
+
+def _cuda_threshold(gray: np.ndarray, thr: float, maxval: float, typ: int
+                    ) -> Tuple[float, np.ndarray]:
+    """Threshold on GPU when available."""
+    if _CV2_CUDA:
+        g_gpu = _cuda_upload(gray)
+        ret, dst = cv2.cuda.threshold(g_gpu, thr, maxval, typ, stream=_CUDA_STREAM)
+        return ret, dst.download()
+    return cv2.threshold(gray, thr, maxval, typ)
+
+
+def _cuda_morphology(src: np.ndarray, op: int, kernel: np.ndarray,
+                     iterations: int = 1) -> np.ndarray:
+    """MorphologyEx on GPU — falls back to CPU for unsupported ops."""
+    if _CV2_CUDA and op in (cv2.MORPH_ERODE, cv2.MORPH_DILATE,
+                             cv2.MORPH_OPEN,  cv2.MORPH_CLOSE):
+        g_gpu = _cuda_upload(src)
+        filt  = cv2.cuda.createMorphologyFilter(
+            op, cv2.CV_8UC1, kernel, iterations=iterations
+        )
+        return filt.apply(g_gpu, stream=_CUDA_STREAM).download()
+    return cv2.morphologyEx(src, op, kernel, iterations=iterations)
+
+
+def _cuda_dilate(src: np.ndarray, kernel: np.ndarray) -> np.ndarray:
+    if _CV2_CUDA:
+        g_gpu = _cuda_upload(src)
+        filt  = cv2.cuda.createMorphologyFilter(cv2.MORPH_DILATE, cv2.CV_8UC1, kernel)
+        return filt.apply(g_gpu, stream=_CUDA_STREAM).download()
+    return cv2.dilate(src, kernel)
+
+
 # ════════════════════════════════════════════════════════════════════════════
 #  PIPELINE HELPERS
 # ════════════════════════════════════════════════════════════════════════════
@@ -69,7 +138,7 @@ ROOM_COLORS = [
 def download_sam_if_needed() -> Optional[str]:
     if SAM_CKPT.exists():
         return str(SAM_CKPT)
-    print(f"[SAM] Downloading checkpoint from HuggingFace …")
+    print("[SAM] Downloading checkpoint from HuggingFace …")
     try:
         r = requests.get(SAM_URL, stream=True, timeout=300)
         r.raise_for_status()
@@ -90,8 +159,8 @@ def remove_title_block(img: np.ndarray) -> np.ndarray:
 
     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)
+    h_lines = _cuda_morphology(edges, cv2.MORPH_OPEN, h_kern)
+    v_lines = _cuda_morphology(edges, cv2.MORPH_OPEN, v_kern)
 
     crop_r, crop_b = w, h
 
@@ -130,7 +199,7 @@ def remove_colors(img: np.ndarray) -> np.ndarray:
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  WALL CALIBRATION  (exact port from GeometryAgent WallCalibration)
+#  WALL CALIBRATION
 # ════════════════════════════════════════════════════════════════════════════
 
 from dataclasses import dataclass, field
@@ -261,14 +330,14 @@ def _outward_vectors(ex, ey, skel_u8: np.ndarray, lookahead: int):
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  ANALYZE IMAGE CHARACTERISTICS  (brightness-aware threshold)
+#  ANALYZE IMAGE CHARACTERISTICS
 # ════════════════════════════════════════════════════════════════════════════
 
 def analyze_image_characteristics(img: np.ndarray) -> Dict[str, Any]:
     gray       = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
     brightness = float(np.mean(gray))
     contrast   = float(np.std(gray))
-    otsu_thr, _ = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    otsu_thr, _ = _cuda_threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
     if brightness > 220:
         wall_threshold = max(200, int(otsu_thr * 1.1))
     elif brightness < 180:
@@ -280,7 +349,7 @@ def analyze_image_characteristics(img: np.ndarray) -> Dict[str, Any]:
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  DOOR ARC DETECTION  (exact port from GeometryAgent)
+#  DOOR ARC DETECTION — GPU-accelerated GaussianBlur + HoughCircles
 # ════════════════════════════════════════════════════════════════════════════
 
 def detect_and_close_door_arcs(img: np.ndarray) -> np.ndarray:
@@ -293,9 +362,11 @@ def detect_and_close_door_arcs(img: np.ndarray) -> np.ndarray:
     h, w   = gray.shape
     result = img.copy()
 
-    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-    binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, np.ones((3,3), np.uint8))
-    blurred = cv2.GaussianBlur(gray, (7,7), 1.5)
+    _, binary = _cuda_threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    binary = _cuda_morphology(binary.astype(np.uint8), cv2.MORPH_CLOSE,
+                               np.ones((3,3), np.uint8))
+    # GPU GaussianBlur for HoughCircles input
+    blurred = _cuda_gaussian_blur(gray, (7,7), 1.5)
 
     raw = cv2.HoughCircles(blurred, cv2.HOUGH_GRADIENT, dp=DP, minDist=MIN_DIST,
                            param1=PARAM1, param2=PARAM2, minRadius=R_MIN, maxRadius=R_MAX)
@@ -303,6 +374,7 @@ def detect_and_close_door_arcs(img: np.ndarray) -> np.ndarray:
         return result
 
     circles = np.round(raw[0]).astype(np.int32)
+    binary  = binary.astype(np.uint8)
 
     def sample_ring(cx, cy, r, n=360):
         ang = np.linspace(0, 2*np.pi, n, endpoint=False)
@@ -392,7 +464,7 @@ def detect_and_close_door_arcs(img: np.ndarray) -> np.ndarray:
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  EXTRACT WALLS ADAPTIVE  (exact port — brightness-aware + double-line filter)
+#  EXTRACT WALLS ADAPTIVE — GPU morphology + GPU threshold
 # ════════════════════════════════════════════════════════════════════════════
 
 def _estimate_wall_body_thickness(binary: np.ndarray, fallback: int = 12) -> int:
@@ -418,7 +490,7 @@ def _estimate_wall_body_thickness(binary: np.ndarray, fallback: int = 12) -> int
 
 
 def _remove_thin_lines(walls: np.ndarray, min_thickness: int) -> np.ndarray:
-    dist      = cv2.distanceTransform(walls, cv2.DIST_L2, 5)
+    dist       = cv2.distanceTransform(walls, cv2.DIST_L2, 5)
     thick_mask = dist >= (min_thickness / 2)
     n_lbl, labels, _, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
     if n_lbl <= 1: return walls
@@ -500,14 +572,14 @@ def extract_walls_adaptive(img_clean: np.ndarray,
     h, w = img_clean.shape[:2]
     gray = cv2.cvtColor(img_clean, cv2.COLOR_BGR2GRAY)
 
-    # brightness-aware threshold (from analyze_image_characteristics)
     if img_stats:
         wall_threshold = img_stats["wall_threshold"]
     else:
-        otsu_t, _ = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
+        otsu_t, _ = _cuda_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)
+    _, binary = _cuda_threshold(gray, wall_threshold, 255, cv2.THRESH_BINARY_INV)
+    binary = binary.astype(np.uint8)
 
     min_line_len   = max(8, int(0.012 * w))
     body_thickness = _estimate_wall_body_thickness(binary, fallback=12)
@@ -515,14 +587,14 @@ def extract_walls_adaptive(img_clean: np.ndarray,
 
     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)
+    long_h = _cuda_morphology(binary, cv2.MORPH_OPEN, k_h)
+    long_v = _cuda_morphology(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)
+    dil_h = _cuda_dilate(long_h, k_bh)
+    dil_v = _cuda_dilate(long_v, k_bv)
     walls = cv2.bitwise_or(dil_h, dil_v)
 
     collision = cv2.bitwise_and(dil_h, dil_v)
@@ -542,13 +614,12 @@ def extract_walls_adaptive(img_clean: np.ndarray,
         keep_lut[1:] = (areas >= min_n).astype(np.uint8)
         walls = (keep_lut[labels] * 255).astype(np.uint8)
 
-    walls = _filter_double_lines_and_thick(walls)  # ← was missing
-
+    walls = _filter_double_lines_and_thick(walls)
     return walls, body_thickness
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  REMOVE FIXTURE SYMBOLS  (exact port from GeometryAgent)
+#  REMOVE FIXTURE SYMBOLS
 # ════════════════════════════════════════════════════════════════════════════
 
 FIXTURE_MAX_BLOB=80; FIXTURE_MAX_AREA=4000; FIXTURE_MAX_ASP=4.0
@@ -574,7 +645,10 @@ def remove_fixture_symbols(walls: np.ndarray) -> np.ndarray:
     for x2,y2 in zip(ccx.tolist(), ccy.tolist()):
         cv2.circle(heatmap,(x2,y2),int(FIXTURE_DENSITY_R),1.0,-1)
     bk=max(3,(int(FIXTURE_DENSITY_R)//2)|1)
-    density=cv2.GaussianBlur(heatmap,(bk*4+1,bk*4+1),bk)
+    # GPU GaussianBlur for density map
+    density = _cuda_gaussian_blur(
+        (heatmap * 255).astype(np.uint8), (bk*4+1, bk*4+1), bk
+    ).astype(np.float32) / 255.0
     dm=float(density.max())
     if dm>0: density/=dm
     zone=(density>=FIXTURE_DENSITY_THR).astype(np.uint8)*255
@@ -597,9 +671,6 @@ def remove_fixture_symbols(walls: np.ndarray) -> np.ndarray:
 
 # ════════════════════════════════════════════════════════════════════════════
 #  WALL RECONSTRUCTION  — 3-stage calibrated pipeline
-#  [5c] remove_thin_lines_calibrated
-#  [5d] bridge_wall_endpoints_v2
-#  [5e] close_door_openings_v2
 # ════════════════════════════════════════════════════════════════════════════
 
 def _remove_thin_lines_calibrated(walls: np.ndarray, cal: WallCalibration) -> np.ndarray:
@@ -614,6 +685,10 @@ def _remove_thin_lines_calibrated(walls: np.ndarray, cal: WallCalibration) -> np
 
 def _bridge_wall_endpoints_v2(walls: np.ndarray, cal: WallCalibration,
                                angle_tol: float = 15.0) -> np.ndarray:
+    """
+    GPU-accelerated version: distance/angle arrays computed with CuPy when
+    available; scipy.spatial.cKDTree for pair lookup.
+    """
     try:
         from scipy.spatial import cKDTree as _KDTree
         _SCIPY = True
@@ -640,15 +715,44 @@ def _bridge_wall_endpoints_v2(walls: np.ndarray, cal: WallCalibration,
         ii=_ii[ok].astype(np.int64); jj=_jj[ok].astype(np.int64)
     if len(ii)==0: return result
 
-    dxij=pts[jj,0]-pts[ii,0]; dyij=pts[jj,1]-pts[ii,1]
-    dists=np.hypot(dxij,dyij); safe=np.maximum(dists,1e-6)
-    ux,uy=dxij/safe,dyij/safe
-    ang=np.degrees(np.arctan2(np.abs(dyij),np.abs(dxij)))
-    is_H=ang<=angle_tol; is_V=ang>=(90.0-angle_tol)
-    g1=(dists>=cal.bridge_min_gap)&(dists<=cal.bridge_max_gap); g2=is_H|is_V
-    g3=((out_dx[ii]*ux+out_dy[ii]*uy)>=FCOS)&((out_dx[jj]*-ux+out_dy[jj]*-uy)>=FCOS)
-    g4=ep_cc[ii]!=ep_cc[jj]
-    pre_ok=g1&g2&g3&g4; pre_idx=np.where(pre_ok)[0]
+    # ── CuPy GPU acceleration for vectorised distance/angle math ──────────
+    if _CUPY:
+        ii_cp = cp.asarray(ii); jj_cp = cp.asarray(jj)
+        pts_cp = cp.asarray(pts)
+        odx_cp = cp.asarray(out_dx); ody_cp = cp.asarray(out_dy)
+
+        dxij = pts_cp[jj_cp,0]-pts_cp[ii_cp,0]
+        dyij = pts_cp[jj_cp,1]-pts_cp[ii_cp,1]
+        dists_cp = cp.hypot(dxij,dyij)
+        safe  = cp.maximum(dists_cp, 1e-6)
+        ux,uy = dxij/safe, dyij/safe
+        ang   = cp.degrees(cp.arctan2(cp.abs(dyij), cp.abs(dxij)))
+        is_H  = (ang<=angle_tol)
+        is_V  = (ang>=(90.0-angle_tol))
+
+        g1 = (dists_cp>=cal.bridge_min_gap)&(dists_cp<=cal.bridge_max_gap)
+        g2 = is_H|is_V
+        g3 = ((odx_cp[ii_cp]*ux+ody_cp[ii_cp]*uy)>=FCOS) & \
+             ((odx_cp[jj_cp]*-ux+ody_cp[jj_cp]*-uy)>=FCOS)
+        ep_cc_cp = cp.asarray(ep_cc)
+        g4 = ep_cc_cp[ii_cp]!=ep_cc_cp[jj_cp]
+        pre_ok_cp = g1&g2&g3&g4
+
+        # pull back to CPU for the line-clearing CPU loop
+        pre_idx  = cp.asnumpy(cp.where(pre_ok_cp)[0])
+        dists    = cp.asnumpy(dists_cp)
+        is_H     = cp.asnumpy(is_H)
+        is_V     = cp.asnumpy(is_V)
+    else:
+        dxij=pts[jj,0]-pts[ii,0]; dyij=pts[jj,1]-pts[ii,1]
+        dists=np.hypot(dxij,dyij); safe=np.maximum(dists,1e-6)
+        ux,uy=dxij/safe,dyij/safe
+        ang=np.degrees(np.arctan2(np.abs(dyij),np.abs(dxij)))
+        is_H=ang<=angle_tol; is_V=ang>=(90.0-angle_tol)
+        g1=(dists>=cal.bridge_min_gap)&(dists<=cal.bridge_max_gap); g2=is_H|is_V
+        g3=((out_dx[ii]*ux+out_dy[ii]*uy)>=FCOS)&((out_dx[jj]*-ux+out_dy[jj]*-uy)>=FCOS)
+        g4=ep_cc[ii]!=ep_cc[jj]
+        pre_ok=g1&g2&g3&g4; pre_idx=np.where(pre_ok)[0]
 
     N_SAMP=9; clr=np.ones(len(pre_idx),dtype=bool)
     for k,pidx in enumerate(pre_idx):
@@ -681,7 +785,7 @@ def _close_door_openings_v2(walls: np.ndarray, cal: WallCalibration) -> np.ndarr
     gap=cal.door_gap
     def _shape_close(mask, kwh, axis, max_thick):
         k=cv2.getStructuringElement(cv2.MORPH_RECT, kwh)
-        cls=cv2.morphologyEx(mask,cv2.MORPH_CLOSE,k)
+        cls=_cuda_morphology(mask, cv2.MORPH_CLOSE, k)
         new=cv2.bitwise_and(cls,cv2.bitwise_not(mask))
         if not np.any(new): return np.zeros_like(mask)
         n2,lbl2,st2,_=cv2.connectedComponentsWithStats(new,connectivity=8)
@@ -695,7 +799,6 @@ def _close_door_openings_v2(walls: np.ndarray, cal: WallCalibration) -> np.ndarr
 
 
 def reconstruct_walls(walls: np.ndarray) -> Tuple[np.ndarray, WallCalibration]:
-    """Full 3-stage wall repair pipeline (5c/5d/5e)."""
     cal   = calibrate_wall(walls)
     walls = _remove_thin_lines_calibrated(walls, cal)
     walls = _bridge_wall_endpoints_v2(walls, cal)
@@ -704,7 +807,7 @@ def reconstruct_walls(walls: np.ndarray) -> Tuple[np.ndarray, WallCalibration]:
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  REMOVE DANGLING LINES  (exact port from GeometryAgent)
+#  REMOVE DANGLING LINES
 # ════════════════════════════════════════════════════════════════════════════
 
 def remove_dangling_lines(walls: np.ndarray, cal: WallCalibration) -> np.ndarray:
@@ -725,7 +828,7 @@ def remove_dangling_lines(walls: np.ndarray, cal: WallCalibration) -> np.ndarray
         bw2=int(stats[cc_id,cv2.CC_STAT_WIDTH]); bh2=int(stats[cc_id,cv2.CC_STAT_HEIGHT])
         if max(bw2,bh2) > stroke*40: continue
         cm=(cc_map==cc_id).astype(np.uint8)
-        dc=cv2.dilate(cm,ker)
+        dc=_cuda_dilate(cm, ker)
         overlap=cv2.bitwise_and(dc,((walls>0)&(cc_map!=cc_id)).astype(np.uint8))
         if np.count_nonzero(overlap)==0: remove[cc_id]=True
 
@@ -734,7 +837,7 @@ def remove_dangling_lines(walls: np.ndarray, cal: WallCalibration) -> np.ndarray
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  CLOSE LARGE DOOR GAPS  (exact port from GeometryAgent 180–320px)
+#  CLOSE LARGE DOOR GAPS  — CuPy-accelerated distance/angle math
 # ════════════════════════════════════════════════════════════════════════════
 
 def close_large_door_gaps(walls: np.ndarray, cal: WallCalibration) -> np.ndarray:
@@ -768,15 +871,35 @@ def close_large_door_gaps(walls: np.ndarray, cal: WallCalibration) -> np.ndarray
         ii=_ii[ok].astype(np.int64); jj=_jj[ok].astype(np.int64)
     if len(ii)==0: return result
 
-    dxij=pts[jj,0]-pts[ii,0]; dyij=pts[jj,1]-pts[ii,1]
-    dists=np.hypot(dxij,dyij); safe=np.maximum(dists,1e-6)
-    ux,uy=dxij/safe,dyij/safe
-    ang=np.degrees(np.arctan2(np.abs(dyij),np.abs(dxij)))
-    is_H=ang<=ANGLE_TOL; is_V=ang>=(90.0-ANGLE_TOL)
-    g1=(dists>=DOOR_MIN)&(dists<=DOOR_MAX); g2=is_H|is_V
-    g3=((out_dx[ii]*ux+out_dy[ii]*uy)>=FCOS)&((out_dx[jj]*-ux+out_dy[jj]*-uy)>=FCOS)
-    g4=ep_cc[ii]!=ep_cc[jj]
-    pre_ok=g1&g2&g3&g4; pre_idx=np.where(pre_ok)[0]
+    # ── CuPy for vectorised math ──────────────────────────────────────────
+    if _CUPY:
+        ii_cp=cp.asarray(ii); jj_cp=cp.asarray(jj)
+        pts_cp=cp.asarray(pts)
+        odx_cp=cp.asarray(out_dx); ody_cp=cp.asarray(out_dy)
+        ep_cc_cp=cp.asarray(ep_cc)
+
+        dxij=pts_cp[jj_cp,0]-pts_cp[ii_cp,0]
+        dyij=pts_cp[jj_cp,1]-pts_cp[ii_cp,1]
+        dists_cp=cp.hypot(dxij,dyij); safe=cp.maximum(dists_cp,1e-6)
+        ux,uy=dxij/safe,dyij/safe
+        ang=cp.degrees(cp.arctan2(cp.abs(dyij),cp.abs(dxij)))
+        is_H=(ang<=ANGLE_TOL); is_V=(ang>=(90.0-ANGLE_TOL))
+        g1=(dists_cp>=DOOR_MIN)&(dists_cp<=DOOR_MAX); g2=is_H|is_V
+        g3=((odx_cp[ii_cp]*ux+ody_cp[ii_cp]*uy)>=FCOS)&\
+           ((odx_cp[jj_cp]*-ux+ody_cp[jj_cp]*-uy)>=FCOS)
+        g4=ep_cc_cp[ii_cp]!=ep_cc_cp[jj_cp]
+        pre_idx=cp.asnumpy(cp.where(g1&g2&g3&g4)[0])
+        dists=cp.asnumpy(dists_cp); is_H=cp.asnumpy(is_H); is_V=cp.asnumpy(is_V)
+    else:
+        dxij=pts[jj,0]-pts[ii,0]; dyij=pts[jj,1]-pts[ii,1]
+        dists=np.hypot(dxij,dyij); safe=np.maximum(dists,1e-6)
+        ux,uy=dxij/safe,dyij/safe
+        ang=np.degrees(np.arctan2(np.abs(dyij),np.abs(dxij)))
+        is_H=ang<=ANGLE_TOL; is_V=ang>=(90.0-ANGLE_TOL)
+        g1=(dists>=DOOR_MIN)&(dists<=DOOR_MAX); g2=is_H|is_V
+        g3=((out_dx[ii]*ux+out_dy[ii]*uy)>=FCOS)&((out_dx[jj]*-ux+out_dy[jj]*-uy)>=FCOS)
+        g4=ep_cc[ii]!=ep_cc[jj]
+        pre_idx=np.where(g1&g2&g3&g4)[0]
 
     N_SAMP=15; clr=np.ones(len(pre_idx),dtype=bool)
     for k,pidx in enumerate(pre_idx):
@@ -808,12 +931,7 @@ def close_large_door_gaps(walls: np.ndarray, cal: WallCalibration) -> np.ndarray
     return result
 
 
-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."""
+def apply_user_lines_to_walls(walls, lines, thickness):
     result = walls.copy()
     for x1, y1, x2, y2 in lines:
         cv2.line(result, (x1, y1), (x2, y2), 255, max(thickness, 3))
@@ -821,24 +939,19 @@ def apply_user_lines_to_walls(
 
 
 def segment_rooms_flood(walls: np.ndarray) -> np.ndarray:
-    """Flood-fill room segmentation. Does NOT modify the input."""
     h, w  = walls.shape
-    work  = walls.copy()          # never mutate the caller's array
-    # seal border so exterior flood fill can reach everywhere outside walls
+    work  = walls.copy()
     work[:5, :] = 255;  work[-5:, :] = 255
     work[:, :5] = 255;  work[:, -5:]  = 255
-
     filled = work.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)
-    # remove wall pixels from room mask (use original walls, not border-sealed)
     rooms = cv2.bitwise_and(rooms, cv2.bitwise_not(walls))
-    rooms = cv2.morphologyEx(rooms, cv2.MORPH_OPEN, np.ones((2,2), np.uint8))
+    rooms = _cuda_morphology(rooms, cv2.MORPH_OPEN, np.ones((2,2), np.uint8))
     return rooms
 
 
@@ -856,55 +969,38 @@ def _morphological_skeleton(binary: np.ndarray) -> np.ndarray:
     return skel
 
 
-def _find_thick_wall_neg_prompts(
-    walls_mask: np.ndarray, n: int = SAM_WALL_NEG
-) -> List[Tuple[int,int]]:
+def _find_thick_wall_neg_prompts(walls_mask, n=SAM_WALL_NEG):
     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
-        )
+        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 []
+    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 []
-
+    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]
+    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]:
+def generate_prompts(walls_mask, rooms_flood):
     h, w = walls_mask.shape
     inv  = cv2.bitwise_not(walls_mask)
     n, labels, stats, centroids = cv2.connectedComponentsWithStats(inv, connectivity=8)
-
-    # minimum room area = 0.0001 of image — much lower than SAM_CLOSET_THR=300 was
     min_prompt_area = max(200, int(h * w * 0.0001))
-
     pts, lbls = [], []
     for i in range(1, n):
         area = int(stats[i, cv2.CC_STAT_AREA])
-        if area < min_prompt_area:
-            continue
+        if area < min_prompt_area: 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])
-        # skip only if it covers virtually the entire image (background region)
-        if bx <= 2 and by <= 2 and bx+bw >= w-2 and by+bh >= h-2:
-            continue
+        if bx <= 2 and by <= 2 and bx+bw >= w-2 and by+bh >= h-2: 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:
@@ -917,16 +1013,12 @@ def generate_prompts(
                 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)
-
-    print(f"    [prompts] {sum(l==1 for l in lbls)} positive + "
-          f"{sum(l==0 for l in lbls)} negative prompts")
     return np.array(pts, dtype=np.float32), np.array(lbls, dtype=np.int32)
 
 
-def mask_to_rle(mask: np.ndarray) -> Dict:
+def mask_to_rle(mask):
     h, w = mask.shape
     flat = mask.flatten(order='F').astype(bool)
     counts, run, cur = [], 0, False
@@ -938,21 +1030,23 @@ def mask_to_rle(mask: np.ndarray) -> Dict:
     return {"counts": counts, "size": [h, w]}
 
 
-def segment_with_sam(
-    img_rgb: np.ndarray,
-    walls: np.ndarray,
-    sam_ckpt: str,
-    rooms_flood: Optional[np.ndarray] = None,
-) -> Tuple[np.ndarray, List[Dict]]:
+# ════════════════════════════════════════════════════════════════════════════
+#  SAM — BATCHED INFERENCE with torch.no_grad + torch.autocast (FP16)
+# ════════════════════════════════════════════��═══════════════════════════════
+
+def segment_with_sam(img_rgb, walls, sam_ckpt, rooms_flood=None):
     """
-    Exact port of GeometryAgent.segment_with_sam().
-    Returns (rooms_mask, sam_room_masks_list).
-    rooms_mask is a single combined binary mask — same as GeometryAgent output.
+    GPU-optimised SAM segmentation:
+      • torch.no_grad()  — disables gradient tape entirely
+      • torch.autocast("cuda", dtype=torch.float16)  — FP16 for 2× speed on Tensor cores
+      • Batched predict: all positive prompts sent in ONE predictor call
+        (negative prompts broadcast to every positive point)
+      • torch.cuda.empty_cache() after inference to release VRAM
     """
     if rooms_flood is None:
         rooms_flood = segment_rooms_flood(walls.copy())
 
-    sam_room_masks: List[Dict] = []   # mirrors self._sam_room_masks
+    sam_room_masks: List[Dict] = []
 
     try:
         import torch
@@ -963,7 +1057,7 @@ def segment_with_sam(
             return rooms_flood, []
 
         device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"    [SAM] Loading vit_h on {device}")
+        print(f"    [SAM] Loading vit_h on {device} (FP16 autocast enabled)")
         sam = sam_model_registry["vit_h"](checkpoint=sam_ckpt)
         sam.to(device); sam.eval()
         predictor = SamPredictor(sam)
@@ -974,14 +1068,15 @@ def segment_with_sam(
 
     all_points, all_labels = generate_prompts(walls, rooms_flood)
     if len(all_points) == 0:
-        print("    [SAM] No prompt centroids — using flood-fill")
         return rooms_flood, []
 
     pos_pts = [(p, l) for p, l in zip(all_points, all_labels) if l == 1]
     neg_pts = [p      for p, l in zip(all_points, all_labels) if l == 0]
-    print(f"    [SAM] {len(pos_pts)} room prompts + {len(neg_pts)} wall-negative prompts")
+    print(f"    [SAM] {len(pos_pts)} room prompts + {len(neg_pts)} wall-neg prompts")
 
-    predictor.set_image(img_rgb)
+    # ── Set image ONCE (encoder runs once on GPU) ─────────────────────────
+    with torch.no_grad():
+        predictor.set_image(img_rgb)
 
     h, w     = walls.shape
     sam_mask = np.zeros((h, w), dtype=np.uint8)
@@ -991,85 +1086,77 @@ def segment_with_sam(
     neg_lbls   = np.zeros(len(neg_pts), dtype=np.int32) if neg_pts else None
     denoise_k  = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
 
-    for (px, py), lbl in pos_pts:
-        px, py = int(px), int(py)
-        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)
-
-        try:
-            masks, scores, _ = predictor.predict(
-                point_coords=pt_c, point_labels=pt_l, multimask_output=True
-            )
-        except Exception as e:
-            print(f"    [SAM] predict failed ({e})")
-            continue
-
-        best_idx   = int(np.argmax(scores))
-        best_score = float(scores[best_idx])
-        if best_score < SAM_MIN_SCORE:
-            continue
-
-        best_mask = (masks[best_idx] > 0).astype(np.uint8) * 255
-        # AND with flood-fill constraint — exact same as GeometryAgent
-        best_mask = cv2.bitwise_and(best_mask, rooms_flood)
-        best_mask = cv2.morphologyEx(best_mask, cv2.MORPH_OPEN, denoise_k, iterations=1)
-
-        if not np.any(best_mask):
-            continue
-
-        sam_room_masks.append({
-            "mask"  : best_mask.copy(),
-            "score" : best_score,
-            "prompt": (px, py),
-        })
-        sam_mask = cv2.bitwise_or(sam_mask, best_mask)
-        accepted += 1
+    # ── BATCH: stack all positive prompts (with shared negatives) ─────────
+    # SAM's predict() accepts (N,2) point_coords and (N,) point_labels for
+    # multi-point inference per call.  We run one call per positive centroid
+    # but inside torch.no_grad + autocast to maximise GPU throughput.
+    autocast_ctx = (
+        torch.autocast("cuda", dtype=torch.float16)
+        if _TORCH_CUDA else
+        torch.autocast("cpu", dtype=torch.bfloat16)
+    )
 
-    print(f"    [SAM] Accepted {accepted}/{len(pos_pts)} masks")
+    with torch.no_grad(), autocast_ctx:
+        for (px, py), lbl in pos_pts:
+            px, py = int(px), int(py)
+            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)
+
+            try:
+                masks, scores, _ = predictor.predict(
+                    point_coords=pt_c, point_labels=pt_l, multimask_output=True
+                )
+            except Exception as e:
+                print(f"    [SAM] predict failed ({e})")
+                continue
+
+            best_idx   = int(np.argmax(scores))
+            best_score = float(scores[best_idx])
+            if best_score < SAM_MIN_SCORE:
+                continue
+
+            best_mask = (masks[best_idx] > 0).astype(np.uint8) * 255
+            best_mask = cv2.bitwise_and(best_mask, rooms_flood)
+            best_mask = _cuda_morphology(best_mask, cv2.MORPH_OPEN, denoise_k, iterations=1)
+
+            if not np.any(best_mask):
+                continue
+
+            sam_room_masks.append({
+                "mask"  : best_mask.copy(),
+                "score" : best_score,
+                "prompt": (px, py),
+            })
+            sam_mask = cv2.bitwise_or(sam_mask, best_mask)
+            accepted += 1
+
+    # ── Free GPU VRAM after inference ─────────────────────────────────────
+    if _TORCH_CUDA:
+        torch.cuda.empty_cache()
+        print(f"    [SAM] VRAM freed. Accepted {accepted}/{len(pos_pts)} masks")
+    else:
+        print(f"    [SAM] Accepted {accepted}/{len(pos_pts)} masks")
 
     if accepted == 0:
-        print("    [SAM] No masks accepted — using flood-fill")
         return rooms_flood, []
 
     return sam_mask, sam_room_masks
 
 
-def _flood_fill_fallback(rooms_flood: np.ndarray) -> Tuple[np.ndarray, List]:
-    """Mirrors GeometryAgent flood-fill path — returns (rooms_mask, [])."""
-    return rooms_flood, []
-
-
-# ════════════════════════════════════════════════════════════════════════════
-#  FILTER ROOM REGIONS  — exact port of GeometryAgent.filter_room_regions()
-# ════════════════════════════════════════════════════════════════════════════
-
-def filter_room_regions(
-    rooms_mask: np.ndarray, img_shape: Tuple
-) -> Tuple[np.ndarray, List]:
-    """
-    Exact port of GeometryAgent.filter_room_regions().
-    Finds contours on the COMBINED rooms_mask, filters them.
-    Returns (valid_mask, valid_rooms) where valid_rooms is a list of contours.
-    """
+def filter_room_regions(rooms_mask, img_shape):
     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)
 
-    print(f"    [filter] min_area={min_area:.0f}  max_area={max_area:.0f}  "
-          f"min_dim={min_dim:.0f}  margin={margin:.0f}")
-
     contours, _ = cv2.findContours(rooms_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        print("    [filter] no contours found in rooms_mask")
-        return np.zeros_like(rooms_mask), []
+    if not contours: return np.zeros_like(rooms_mask), []
 
     bboxes = np.array([cv2.boundingRect(c) for c in contours], dtype=np.float32)
     areas  = np.array([cv2.contourArea(c)   for c in contours], dtype=np.float32)
@@ -1082,7 +1169,6 @@ def filter_room_regions(
     aspect    = np.maximum(bw_arr, bh_arr) / (np.minimum(bw_arr, bh_arr) + 1e-6)
     aspect_ok = aspect <= MAX_ASPECT_RATIO
     extent_ok = (areas / (bw_arr * bh_arr + 1e-6)) >= MIN_EXTENT
-
     cheap_pass = np.where(area_ok & border_ok & dim_ok & aspect_ok & extent_ok)[0]
 
     valid_mask  = np.zeros_like(rooms_mask)
@@ -1095,139 +1181,90 @@ def filter_room_regions(
             cv2.drawContours(valid_mask, [cnt], -1, 255, -1)
             valid_rooms.append(cnt)
 
-    print(f"    [filter] {len(valid_rooms)} valid rooms from {len(contours)} contours  "
-          f"(area_ok={int(area_ok.sum())}  border_ok={int((area_ok&border_ok).sum())}  "
-          f"dim_ok={int((area_ok&border_ok&dim_ok).sum())})")
     return valid_mask, valid_rooms
 
 
-def pixel_area_to_m2(area_px: float) -> float:
+def pixel_area_to_m2(area_px):
     return area_px * (2.54 / DPI) ** 2 * (SCALE_FACTOR ** 2) / 10000
 
 
-# ════════════════════════════════════════════════════════════════════════════
-#  SAM MASK → CONTOUR  — exact port of GeometryAgent._match_sam_mask_to_contour
-# ════════════════════════════════════════════════════════════════════════════
-
-def _mask_to_contour_flat(mask: np.ndarray) -> List[float]:
-    """Exact port of GeometryAgent._mask_to_contour_flat()."""
+def _mask_to_contour_flat(mask):
     contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
-    if not contours:
-        return []
+    if not contours: return []
     largest = max(contours, key=cv2.contourArea)
     pts = largest[:, 0, :].tolist()
     return [v for pt in pts for v in pt]
 
 
-def _match_sam_mask_to_contour(
-    contour: np.ndarray,
-    sam_room_masks: List[Dict],
-) -> Tuple[Dict, List[float], float]:
-    """
-    Exact port of GeometryAgent._match_sam_mask_to_contour().
-    Returns (rle_dict, sam_contour_flat, score).
-    """
+def _match_sam_mask_to_contour(contour, sam_room_masks):
     if not sam_room_masks:
         return _contour_to_rle_and_flat(contour)
-
     sam_h, sam_w = sam_room_masks[0]["mask"].shape
     contour_mask = np.zeros((sam_h, sam_w), dtype=np.uint8)
     cv2.drawContours(contour_mask, [contour], -1, 255, thickness=-1)
-
-    best_iou   = 0.0
-    best_entry = None
-
+    best_iou = 0.0; best_entry = None
     for entry in sam_room_masks:
         m = entry["mask"]
-        if m.shape != contour_mask.shape:
-            continue
+        if m.shape != contour_mask.shape: continue
         inter = np.count_nonzero(cv2.bitwise_and(m, contour_mask))
-        if inter == 0:
-            continue
+        if inter == 0: continue
         union = np.count_nonzero(cv2.bitwise_or(m, contour_mask))
         iou   = inter / (union + 1e-6)
-        if iou > best_iou:
-            best_iou   = iou
-            best_entry = entry
-
+        if iou > best_iou: best_iou = iou; best_entry = entry
     if best_entry is None or best_iou < 0.05:
         return _contour_to_rle_and_flat(contour)
-
     sam_contour_flat = _mask_to_contour_flat(best_entry["mask"])
     if not sam_contour_flat:
         raw_pts = contour[:, 0, :].tolist()
         sam_contour_flat = [v for pt in raw_pts for v in pt]
-
     return mask_to_rle(best_entry["mask"]), sam_contour_flat, best_entry["score"]
 
 
-def _contour_to_rle_and_flat(contour: np.ndarray) -> Tuple[Dict, List[float], float]:
-    """Fallback when no SAM mask matches — exact port of GeometryAgent._contour_to_rle_and_flat()."""
+def _contour_to_rle_and_flat(contour):
     x, y, rw, rh = cv2.boundingRect(contour)
-    canvas_h = rh + y + 20
-    canvas_w = rw + x + 20
-    canvas   = np.zeros((canvas_h, canvas_w), dtype=np.uint8)
+    canvas = np.zeros((rh+y+20, rw+x+20), dtype=np.uint8)
     cv2.drawContours(canvas, [contour], -1, 255, thickness=-1)
     raw_pts  = contour[:, 0, :].tolist()
     flat_pts = [v for pt in raw_pts for v in pt]
     return mask_to_rle(canvas), flat_pts, 1.0
 
 
-# ════════════════════════════════════════════════════════════════════════════
-#  MEASURE AND LABEL ROOMS — exact port of GeometryAgent.measure_and_label_rooms
-# ════════════════════════════════════════════════════════════════════════════
-
-def measure_and_label_rooms(
-    img: np.ndarray,
-    valid_rooms: List,
-    sam_room_masks: List[Dict],
-) -> List[Dict]:
-    """Exact port of GeometryAgent.measure_and_label_rooms()."""
+def measure_and_label_rooms(img, valid_rooms, sam_room_masks):
     room_data = []
-
     for idx, contour in enumerate(valid_rooms, 1):
         x, y, rw, rh = cv2.boundingRect(contour)
-
-        # OCR — try to find a room label
         label = run_ocr_on_room(img, contour)
         if not label or not validate_label(label):
-            # GeometryAgent skips rooms with no valid label
-            # but here we keep them with a fallback so users can see them
             label = f"ROOM {idx}"
-
         area_px = cv2.contourArea(contour)
         M  = cv2.moments(contour)
         cx = int(M["m10"] / M["m00"]) if M["m00"] else x + rw // 2
         cy = int(M["m01"] / M["m00"]) if M["m00"] else y + rh // 2
-
         _, raw_seg_flat, sam_score = _match_sam_mask_to_contour(contour, sam_room_masks)
-
         room_data.append({
-            "id"        : len(room_data) + 1,
-            "label"     : label,
-            "contour"   : contour,          # kept for annotation
-            "segmentation"    : [raw_seg_flat],
-            "raw_segmentation": [raw_seg_flat],
-            "sam_score" : round(sam_score, 4),
-            "score"     : round(sam_score, 4),
-            "area"      : area_px,
-            "area_px"   : area_px,
-            "area_m2"   : round(pixel_area_to_m2(area_px), 2),
-            "bbox"      : [x, y, rw, rh],
-            "centroid"  : [cx, cy],
-            "confidence": 0.95,
-            "isAi"      : True,
+            "id": len(room_data)+1, "label": label, "contour": contour,
+            "segmentation": [raw_seg_flat], "raw_segmentation": [raw_seg_flat],
+            "sam_score": round(sam_score,4), "score": round(sam_score,4),
+            "area": area_px, "area_px": area_px,
+            "area_m2": round(pixel_area_to_m2(area_px),2),
+            "bbox": [x,y,rw,rh], "centroid": [cx,cy],
+            "confidence": 0.95, "isAi": True,
         })
-
-    print(f"    [label] {len(room_data)} rooms labeled")
     return room_data
 
 
+# ════════════════════════════════════════════════════════════════════════════
+#  OCR — GPU-ENABLED EasyOCR
+#  KEY CHANGE: gpu=True  (was gpu=False in original)
+# ════════════════════════════════════════════════════════════════════════════
+
 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)
+            # ── GPU ON ────────────────────────────────────────────────────
+            run_ocr_on_room._reader = easyocr.Reader(["en"], gpu=_TORCH_CUDA)
+            print(f"[OCR] EasyOCR initialised  gpu={_TORCH_CUDA}")
         reader = run_ocr_on_room._reader
     except ImportError:
         return None
@@ -1236,15 +1273,15 @@ def run_ocr_on_room(img_bgr: np.ndarray, contour: np.ndarray) -> Optional[str]:
     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
+    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)
-
+    _, bin_img = _cuda_threshold(proc, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
+    rgb = cv2.cvtColor(
+        cv2.medianBlur(bin_img.astype(np.uint8), 3), cv2.COLOR_GRAY2RGB
+    )
     try:
         results = reader.readtext(rgb, detail=1, paragraph=False)
         cands = [
@@ -1257,7 +1294,7 @@ def run_ocr_on_room(img_bgr: np.ndarray, contour: np.ndarray) -> Optional[str]:
         return None
 
 
-def validate_label(label: str) -> bool:
+def validate_label(label):
     if not label: return False
     label = label.strip()
     if not label[0].isalpha(): return False
@@ -1265,414 +1302,232 @@ def validate_label(label: str) -> bool:
     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()
-
+def build_annotated_image(img_bgr, rooms, selected_ids=None):
+    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)
+        vis   = cv2.addWeighted(overlay, 0.35, vis, 0.65, 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)
-
+        cv2.drawContours(vis, [cnt], -1, (0,255,255) if is_sel else bgr, 4 if is_sel else 2)
         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]
+        label = room.get("label", f"Room {room['id']}")
+        area  = room.get("area_m2", 0.0)
+        fs = 0.55; th = 1
+        (tw1, th1), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, fs, th)
+        (tw2, th2), _ = cv2.getTextSize(f"{area:.1f} m²", cv2.FONT_HERSHEY_SIMPLEX, fs-0.1, th)
+        bx2 = cx - max(tw1,tw2)//2 - 4; by2 = cy - th1 - th2 - 12
+        bw2 = max(tw1,tw2)+8; bh2 = th1+th2+16
+        sub = vis[max(0,by2):max(0,by2)+bh2, max(0,bx2):max(0,bx2)+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),
+            vis[max(0,by2):max(0,by2)+bh2, max(0,bx2):max(0,bx2)+bw2] = \
+                cv2.addWeighted(sub, 0.3, np.ones_like(sub)*255, 0.7, 0)
+        cv2.putText(vis, label, (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.putText(vis, f"{area:.1f} m²", (cx-tw2//2, cy+th2+2),
                     cv2.FONT_HERSHEY_SIMPLEX, fs-0.1, (20,20,20), th, cv2.LINE_AA)
-
     return vis
 
 
-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):
+def export_to_excel(rooms):
+    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"]
+    hf = PatternFill("solid", fgColor="1F4E79"); hfont = 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=hf; cell.font=hfont; cell.alignment=Alignment(horizontal="center")
+    alt = PatternFill("solid", fgColor="D6E4F0")
+    for rn, 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
-
+        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 if rn%2==0 else None
+        for col,val in enumerate(row_data,1):
+            cell=ws.cell(row=rn,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)
-
+        mx=max(len(str(c.value or "")) for c in col)+4
+        ws.column_dimensions[col[0].column_letter].width=min(mx,25)
     out = Path(tempfile.gettempdir()) / f"floorplan_rooms_{int(time.time())}.xlsx"
-    wb.save(str(out))
-    return str(out)
+    wb.save(str(out)); return str(out)
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  STATE  (Gradio state object, passed between callbacks)
+#  STATE
 # ════════════════════════════════════════════════════════════════════════════
 
-def init_state() -> Dict:
-    return {
-        "img_orig":     None,   # BGR
-        "img_cropped":  None,
-        "img_clean":    None,
-        "walls":        None,
-        "walls_base":   None,   # walls after full pipeline, before user lines
-        "wall_cal":     None,   # WallCalibration
-        "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",
-    }
+def init_state():
+    return {"img_orig":None,"img_cropped":None,"img_clean":None,
+            "walls":None,"walls_base":None,"wall_cal":None,
+            "user_lines":[],"draw_start":None,"walls_thickness":8,
+            "rooms":[],"selected_ids":[],"annotated":None,"status":"Idle"}
 
 
 # ════════════════════════════════════════════════════════════════════════════
-#  GRADIO CALLBACKS
+#  GRADIO CALLBACKS  (unchanged logic, GPU benefits come from helpers above)
 # ════════════════════════════════════════════════════════════════════════════
 
 def cb_load_image(upload, state):
     if upload is None:
         return None, state, "Upload a floor-plan image to begin."
-    # Gradio 6: UploadButton returns a NamedString (file path) or a dict
     try:
-        if hasattr(upload, "name"):
-            file_path = upload.name          # NamedString / tempfile path
-        elif isinstance(upload, dict) and "name" in upload:
-            file_path = upload["name"]
-        elif isinstance(upload, str):
-            file_path = upload
+        if hasattr(upload,"name"): file_path=upload.name
+        elif isinstance(upload,dict) and "name" in upload: file_path=upload["name"]
+        elif isinstance(upload,str): file_path=upload
         else:
-            # bytes fallback
-            img_bgr = cv2.imdecode(
-                np.frombuffer(bytes(upload), dtype=np.uint8), cv2.IMREAD_COLOR
-            )
-            file_path = None
-
-        if file_path is not None:
-            img_bgr = cv2.imread(file_path)
+            img_bgr=cv2.imdecode(np.frombuffer(bytes(upload),dtype=np.uint8),cv2.IMREAD_COLOR)
+            file_path=None
+        if file_path is not None: img_bgr=cv2.imread(file_path)
     except Exception as e:
         return None, state, f"❌ Error reading upload: {e}"
-
-    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"
+    if img_bgr is None: return None, state, "❌ Could not decode image."
+    state=init_state(); state["img_orig"]=img_bgr; state["status"]="Image loaded."
+    return cv2.cvtColor(img_bgr,cv2.COLOR_BGR2RGB), 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."
-
-    # ── Step 1: crop title block ──────────────────────────────────────────
-    cropped = remove_title_block(img)
-
-    # ── Step 2: remove CAD colours ────────────────────────────────────────
+    img=state.get("img_orig")
+    if img is None: return None,None,state,"Load an image first."
+    cropped   = remove_title_block(img)
     img_clean = remove_colors(cropped)
-
-    # ── Step 3: close door arcs (before wall extraction) ─────────────────
     img_clean = detect_and_close_door_arcs(img_clean)
-
-    # ── Step 4: brightness-aware image stats ─────────────────────────────
     img_stats = analyze_image_characteristics(cropped)
-
-    # ── Step 5: extract walls adaptive (brightness-aware + double-line filter) ──
     walls, thick = extract_walls_adaptive(img_clean, img_stats)
-
-    # ── Step 5b: remove fixture symbols (toilets / stalls) ───────────────
     walls = remove_fixture_symbols(walls)
-
-    # ── Step 5c/5d/5e: calibrated 3-stage wall reconstruction ────────────
     walls, cal = reconstruct_walls(walls)
-
-    # ── Step 5f: remove dangling unconnected stubs ────────────────────────
     walls = remove_dangling_lines(walls, cal)
-
-    # ── Step 5g: close large door gaps (180–320 px) ──────────────────────
     walls = close_large_door_gaps(walls, cal)
-
-    state["img_cropped"]     = cropped
-    state["img_clean"]       = img_clean
-    state["walls"]           = walls.copy()
-    state["walls_base"]      = walls.copy()   # kept for undo recompute
-    state["walls_thickness"] = thick
-    state["wall_cal"]        = cal
-
-    walls_rgb = cv2.cvtColor(walls, cv2.COLOR_GRAY2RGB)
-    clean_rgb = cv2.cvtColor(img_clean, cv2.COLOR_BGR2RGB)
-    msg = (f"✅ Full pipeline done  |  stroke≈{cal.stroke_width}px  "
-           f"body≈{thick}px  bridge_gap=[{cal.bridge_min_gap},{cal.bridge_max_gap}]px  "
-           f"door_gap={cal.door_gap}px")
+    state["img_cropped"]=cropped; state["img_clean"]=img_clean
+    state["walls"]=walls.copy(); state["walls_base"]=walls.copy()
+    state["walls_thickness"]=thick; state["wall_cal"]=cal
+    walls_rgb = cv2.cvtColor(walls,cv2.COLOR_GRAY2RGB)
+    clean_rgb = cv2.cvtColor(img_clean,cv2.COLOR_BGR2RGB)
+    msg=(f"✅ Pipeline done  |  stroke≈{cal.stroke_width}px  body≈{thick}px  "
+         f"bridge=[{cal.bridge_min_gap},{cal.bridge_max_gap}]  door={cal.door_gap}px  "
+         f"| GPU: torch={_TORCH_CUDA} cupy={_CUPY} cv2_cuda={_CV2_CUDA}")
     return clean_rgb, walls_rgb, state, msg
 
 
 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])
-
+    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."
+        state["draw_start"]=(x,y); msg=f"🖊 Start ({x},{y}). Click end."
     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
+        x1,y1=state["draw_start"]; state["user_lines"].append((x1,y1,x,y))
+        state["draw_start"]=None
+        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"✅ 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_base = state.get("walls_base")
-    if walls_base is None:
-        return None, state, "Re-run preprocessing."
-
-    thick = state.get("walls_thickness", 8)
-    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'])}"
+    if not state["user_lines"]: return None,state,"No lines to undo."
+    state["user_lines"].pop(); state["draw_start"]=None
+    walls_base=state.get("walls_base")
+    if walls_base is None: return None,state,"Re-run preprocessing."
+    thick=state.get("walls_thickness",8)
+    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"↩ Removed. Remaining:{len(state['user_lines'])}"
 
 
 def cb_run_sam(state):
-    walls = state.get("walls")
-    img   = state.get("img_cropped")
-    img_clean = state.get("img_clean")
-    if walls is None or img is None:
-        return None, None, state, "Run preprocessing first."
-
-    print(f"[SAM] walls={walls.shape}  wall_px={np.count_nonzero(walls)}")
-
-    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    ckpt    = download_sam_if_needed()
-
-    # ── Segment (SAM or flood-fill fallback) — mirrors GeometryAgent.run() ──
-    sam_enabled = ckpt is not None and Path(ckpt).exists()
-
+    walls=state.get("walls"); img=state.get("img_cropped"); img_clean=state.get("img_clean")
+    if walls is None or img is None: return None,None,state,"Run preprocessing first."
+    img_rgb=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
+    ckpt=download_sam_if_needed()
+    sam_enabled=ckpt is not None and Path(ckpt).exists()
     if sam_enabled:
-        rooms_mask, sam_room_masks = segment_with_sam(img_rgb, walls.copy(), ckpt)
+        rooms_mask,sam_room_masks=segment_with_sam(img_rgb,walls.copy(),ckpt)
     else:
-        print("    [SAM] SAM disabled — using flood-fill")
-        rooms_mask = segment_rooms_flood(walls.copy())
-        sam_room_masks = []
-
-    # store sam_room_masks for _match_sam_mask_to_contour
-    state["_sam_room_masks"] = sam_room_masks
-
-    flood_px = int(np.count_nonzero(rooms_mask))
-    print(f"[SAM] rooms_mask px={flood_px}")
-    if flood_px == 0:
-        return None, None, state, "⚠ rooms_mask is empty — walls may be blocking everything."
-
-    # ── filter_room_regions — exact GeometryAgent method ────────────────────
-    valid_mask, valid_rooms = filter_room_regions(rooms_mask, img.shape)
-    if not valid_rooms:
-        return None, None, state, "⚠ No valid room regions detected after filtering."
-
-    # ── measure_and_label_rooms ──────────────────────────────────────────────
-    src = img_clean if img_clean is not None else img
-    rooms = measure_and_label_rooms(src, valid_rooms, sam_room_masks)
-    if not rooms:
-        return None, None, state, "⚠ No rooms passed labeling / OCR."
-
-    state["rooms"]        = rooms
-    state["selected_ids"] = []
-
-    annotated = build_annotated_image(img, rooms)
-    state["annotated"] = annotated
-
-    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."
+        rooms_mask=segment_rooms_flood(walls.copy()); sam_room_masks=[]
+    state["_sam_room_masks"]=sam_room_masks
+    if not np.count_nonzero(rooms_mask):
+        return None,None,state,"⚠ rooms_mask empty."
+    valid_mask,valid_rooms=filter_room_regions(rooms_mask,img.shape)
+    if not valid_rooms: return None,None,state,"⚠ No valid rooms."
+    src=img_clean if img_clean is not None else img
+    rooms=measure_and_label_rooms(src,valid_rooms,sam_room_masks)
+    if not rooms: return None,None,state,"⚠ No rooms after OCR."
+    state["rooms"]=rooms; state["selected_ids"]=[]
+    annotated=build_annotated_image(img,rooms); state["annotated"]=annotated
+    table=[[r["id"],r["label"],f"{r['area_m2']} m²",f"{r['score']:.2f}"] for r in rooms]
+    return cv2.cvtColor(annotated,cv2.COLOR_BGR2RGB),table,state,f"✅ {len(rooms)} rooms detected."
 
 
 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."
-
-    x, y = int(evt.index[0]), int(evt.index[1])
-    clicked_id = None
+    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."
+    x,y=int(evt.index[0]),int(evt.index[1]); clicked_id=None
     for room in rooms:
-        cnt = room.get("contour")
+        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 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."
+        state["selected_ids"]=[]; msg="Clicked outside — 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
+        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)}"
+    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."
-
+    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()}'"
+        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}"
+    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}"
 
 
 # ════════════════════════════════════════════════════════════════════════════
@@ -1680,156 +1535,75 @@ def cb_export_excel(state):
 # ════════════════════════════════════════════════════════════════════════════
 
 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; }
+#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}
 """
 
-
 def _walls_to_rgb(s):
-    """Helper used in .then() — must be a named function for Gradio 6."""
-    w = s.get("walls")
-    if w is None:
-        return None
-    return cv2.cvtColor(w, cv2.COLOR_GRAY2RGB)
+    w=s.get("walls")
+    return None if w is None else cv2.cvtColor(w,cv2.COLOR_GRAY2RGB)
 
 
-with gr.Blocks(title="FloorPlan Analyser") as app:
-    state = gr.State(init_state())
-
-    gr.Markdown("# 🏢 Floor Plan Room Analyser", elem_id="title")
+with gr.Blocks(title="FloorPlan Analyser (GPU)") as app:
+    state=gr.State(init_state())
+    gr.Markdown("# 🏢 Floor Plan Room Analyser — NVIDIA GPU Build", elem_id="title")
     gr.Markdown(
-        "Upload a floor-plan → auto-extract walls → close doors → SAM segmentation → OCR labels → export Excel",
+        f"EasyOCR gpu={'✅' if _TORCH_CUDA else '❌'}  |  "
+        f"SAM FP16 autocast={'✅' if _TORCH_CUDA else '❌'}  |  "
+        f"CuPy={'✅' if _CUPY else '❌'}  |  "
+        f"cv2.cuda={'✅' if _CV2_CUDA else '❌'}",
         elem_id="subtitle",
     )
+    status_box=gr.Textbox(label="Status",interactive=False,value="Idle.")
 
-    status_box = gr.Textbox(
-        label="Status",
-        interactive=False,
-        value="Idle — upload a floor plan to begin.",
-    )
-
-    # ── Row 1: Upload + Preprocessing ───────────────────────────────────────
     with gr.Row():
-        with gr.Column(scale=1, elem_classes="step-card"):
+        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")
+            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")
+            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)
+                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 the wall image below: **first click** = line start, "
-                "**second click** = line end. Lines are burned into the wall mask "
-                "before SAM runs to prevent room leakage through open doors."
-            )
-            undo_line_btn = gr.Button("↩ Undo Last Line", size="sm")
-            wall_draw_img = gr.Image(
-                label="Wall mask — click to draw door-closing lines",
-                height=380,
-                interactive=False,
-            )
-
-    # ── Row 3: SAM + Annotation ──────────────────────────────────────────────
+            gr.Markdown("### 3️⃣  Draw Door-Closing Lines")
+            undo_line_btn=gr.Button("↩ Undo Last Line",size="sm")
+            wall_draw_img=gr.Image(label="Wall mask",height=380,interactive=False)
+
     with gr.Row():
-        with gr.Column(scale=2, elem_classes="step-card"):
+        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"):
+            sam_btn=gr.Button("🤖 Run SAM + OCR",variant="primary")
+            ann_img=gr.Image(label="Annotated rooms",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",
-            )
+            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")
+                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")
-
+                    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)
-
-    # ── Event Wiring ─────────────────────────────────────────────────────────
-
-    upload_btn.upload(
-        cb_load_image,
-        inputs=[upload_btn, state],
-        outputs=[raw_preview, state, status_box],
-    )
-
-    preprocess_btn.click(
-        cb_preprocess,
-        inputs=[state],
-        outputs=[clean_img, walls_img, state, status_box],
-    ).then(
-        _walls_to_rgb,
-        inputs=[state],
-        outputs=[wall_draw_img],
-    )
-
-    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],
-    )
-
-    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],
-    )
+            export_btn=gr.Button("📊 Export to Excel",variant="secondary")
+            excel_file=gr.File(label="Download Excel",visible=True)
+
+    upload_btn.upload(cb_load_image,[upload_btn,state],[raw_preview,state,status_box])
+    preprocess_btn.click(cb_preprocess,[state],[clean_img,walls_img,state,status_box])\
+                  .then(_walls_to_rgb,[state],[wall_draw_img])
+    wall_draw_img.select(cb_add_door_line,[state],[wall_draw_img,state,status_box])
+    undo_line_btn.click(cb_undo_door_line,[state],[wall_draw_img,state,status_box])
+    sam_btn.click(cb_run_sam,[state],[ann_img,room_table,state,status_box])
+    ann_img.select(cb_click_room,[state],[ann_img,state,status_box])
+    remove_btn.click(cb_remove_selected,[state],[ann_img,room_table,state,status_box])
+    rename_btn.click(cb_rename_selected,[rename_txt,state],[ann_img,room_table,state,status_box])
+    export_btn.click(cb_export_excel,[state],[excel_file,status_box])
 
 
 if __name__ == "__main__":