Create wall_pipeline.py

wall_pipeline.py

@@ -0,0 +1,913 @@
+"""
+Wall Extraction Pipeline — GPU-aware, self-contained
+All heavy NumPy ops are dispatched to GPU (CuPy) when available,
+falling back transparently to CPU NumPy.
+"""
+from __future__ import annotations
+
+import numpy as np
+import cv2
+from dataclasses import dataclass
+from typing import List, Dict, Any, Tuple, Optional
+
+# ── GPU shim ────────────────────────────────────────────────────────────────
+try:
+    import cupy as cp
+    _GPU = True
+    print("[GPU] CuPy available — GPU acceleration ON")
+except ImportError:
+    cp = np  # type: ignore
+    _GPU = False
+    print("[GPU] CuPy not found — running on CPU")
+
+try:
+    from skimage.morphology import skeletonize as _sk_skel
+    _SKIMAGE = True
+except ImportError:
+    _SKIMAGE = False
+
+try:
+    from scipy.spatial import cKDTree
+    _SCIPY = True
+except ImportError:
+    _SCIPY = False
+
+
+def _to_gpu(arr: np.ndarray):
+    return cp.asarray(arr) if _GPU else arr
+
+def _to_cpu(arr) -> np.ndarray:
+    return cp.asnumpy(arr) if _GPU else arr
+
+
+# ── Calibration dataclass ────────────────────────────────────────────────────
+@dataclass
+class WallCalibration:
+    stroke_width      : int = 3
+    min_component_dim : int = 30
+    min_component_area: int = 45
+    bridge_min_gap    : int = 2
+    bridge_max_gap    : int = 14
+    door_gap          : int = 41
+    max_bridge_thick  : int = 15
+
+    def as_dict(self):
+        return {
+            "stroke_width"      : self.stroke_width,
+            "min_component_dim" : self.min_component_dim,
+            "min_component_area": self.min_component_area,
+            "bridge_min_gap"    : self.bridge_min_gap,
+            "bridge_max_gap"    : self.bridge_max_gap,
+            "door_gap"          : self.door_gap,
+            "max_bridge_thick"  : self.max_bridge_thick,
+        }
+
+
+# ── RLE helpers ──────────────────────────────────────────────────────────────
+def mask_to_rle(mask: np.ndarray) -> Dict[str, Any]:
+    h, w  = mask.shape
+    flat  = mask.flatten(order='F').astype(bool)
+    counts: List[int] = []
+    current_val = False
+    run = 0
+    for v in flat:
+        if v == current_val:
+            run += 1
+        else:
+            counts.append(run)
+            run = 1
+            current_val = v
+    counts.append(run)
+    if mask[0, 0]:
+        counts.insert(0, 0)
+    return {"counts": counts, "size": [h, w]}
+
+
+def _mask_to_contour_flat(mask: np.ndarray) -> List[float]:
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    if not contours:
+        return []
+    largest = max(contours, key=cv2.contourArea)
+    pts = largest[:, 0, :].tolist()
+    return [v for pt in pts for v in pt]
+
+
+# ── Core pipeline class ───────────────────────────────────────────────────────
+class WallPipeline:
+    """
+    Stateless (per-call) wall extraction + room segmentation.
+    All intermediate images are returned in a log dict for the UI.
+    """
+
+    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
+
+    FIXTURE_MAX_BLOB_DIM      = 80
+    FIXTURE_MAX_AREA          = 4000
+    FIXTURE_MAX_ASPECT        = 4.0
+    FIXTURE_DENSITY_RADIUS    = 50
+    FIXTURE_DENSITY_THRESHOLD = 0.35
+    FIXTURE_MIN_ZONE_AREA     = 1500
+
+    DOOR_ARC_MIN_RADIUS = 60
+    DOOR_ARC_MAX_RADIUS = 320
+
+    def __init__(self, progress_cb=None):
+        self.progress_cb = progress_cb or (lambda msg, pct: None)
+        self._wall_cal: Optional[WallCalibration] = None
+        self._wall_thickness = 8
+        self.stage_images: Dict[str, np.ndarray] = {}
+
+    def _log(self, msg: str, pct: int):
+        self.progress_cb(msg, pct)
+
+    def _save(self, key: str, img: np.ndarray):
+        self.stage_images[key] = img.copy()
+
+    # ── Public entry point ────────────────────────────────────────────────────
+    def run(self, img_bgr: np.ndarray,
+            extra_door_lines: List[Tuple[int,int,int,int]] = None
+            ) -> Tuple[np.ndarray, np.ndarray, WallCalibration]:
+        """
+        Returns (wall_mask, room_mask, calibration).
+        extra_door_lines: list of (x1,y1,x2,y2) to paint onto wall mask before room seg.
+        """
+        self.stage_images = {}
+        self._log("Step 1 — Removing title block", 5)
+        img = self._remove_title_block(img_bgr)
+        self._save("01_title_removed", img)
+
+        self._log("Step 2 — Removing colored annotations", 12)
+        img = self._remove_colors(img)
+        self._save("02_colors_removed", img)
+
+        self._log("Step 3 — Closing door arcs", 20)
+        img = self._close_door_arcs(img)
+        self._save("03_door_arcs", img)
+
+        self._log("Step 4 — Extracting walls", 30)
+        walls = self._extract_walls(img)
+        self._save("04_walls_raw", walls)
+
+        self._log("Step 5b — Removing fixture symbols", 38)
+        walls = self._remove_fixtures(walls)
+        self._save("05b_no_fixtures", walls)
+
+        self._log("Step 5c — Calibrating & removing thin lines", 45)
+        self._wall_cal = self._calibrate_wall(walls)
+        walls = self._remove_thin_lines_calibrated(walls)
+        self._save("05c_thin_removed", walls)
+
+        self._log("Step 5d — Bridging wall endpoints", 55)
+        walls = self._bridge_endpoints(walls)
+        self._save("05d_bridged", walls)
+
+        self._log("Step 5e — Closing door openings", 63)
+        walls = self._close_door_openings(walls)
+        self._save("05e_doors_closed", walls)
+
+        self._log("Step 5f — Removing dangling lines", 70)
+        walls = self._remove_dangling(walls)
+        self._save("05f_dangling_removed", walls)
+
+        self._log("Step 5g — Sealing large door gaps", 76)
+        walls = self._close_large_gaps(walls)
+        self._save("05g_large_gaps", walls)
+
+        # Paint extra door-seal lines from UI
+        if extra_door_lines:
+            self._log("Applying manual door seal lines", 79)
+            lw = max(3, self._wall_cal.stroke_width if self._wall_cal else 3)
+            for x1, y1, x2, y2 in extra_door_lines:
+                cv2.line(walls, (x1, y1), (x2, y2), 255, lw)
+            self._save("05h_manual_doors", walls)
+
+        self._log("Step 7 — Flood-fill room segmentation", 85)
+        rooms = self._segment_rooms(walls)
+        self._save("07_rooms", rooms)
+
+        self._log("Step 8 — Filtering room regions", 93)
+        valid_mask, _ = self._filter_rooms(rooms, img_bgr.shape)
+        self._save("08_rooms_filtered", valid_mask)
+
+        self._log("Done", 100)
+        return walls, valid_mask, self._wall_cal
+
+    # ── Stage 1: Remove title block ───────────────────────────────────────────
+    def _remove_title_block(self, 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_right, crop_bottom = w, h
+        right_region = v_lines[:, int(w * 0.7):]
+        if np.any(right_region):
+            vp = np.where(np.sum(right_region, axis=0) > h * 0.3)[0]
+            if len(vp):
+                crop_right = int(w * 0.7) + vp[0] - 10
+        bot_region = h_lines[int(h * 0.7):, :]
+        if np.any(bot_region):
+            hp = np.where(np.sum(bot_region, axis=1) > w * 0.3)[0]
+            if len(hp):
+                crop_bottom = int(h * 0.7) + hp[0] - 10
+        return img[:crop_bottom, :crop_right].copy()
+
+    # ── Stage 2: Remove colors ────────────────────────────────────────────────
+    def _remove_colors(self, img: np.ndarray) -> np.ndarray:
+        if _GPU:
+            g_img = _to_gpu(img.astype(np.int32))
+            b, gch, r = g_img[:,:,0], g_img[:,:,1], g_img[:,:,2]
+            gray = (0.114*b + 0.587*gch + 0.299*r)
+            chroma = cp.maximum(cp.maximum(r,gch),b) - cp.minimum(cp.minimum(r,gch),b)
+            erase = (chroma > 15) & (gray < 240)
+            result = _to_gpu(img.copy())
+            result[erase] = cp.array([255,255,255], dtype=cp.uint8)
+            return _to_cpu(result)
+        else:
+            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
+
+    # ── Stage 3: Close door arcs ──────────────────────────────────────────────
+    def _close_door_arcs(self, img: np.ndarray) -> np.ndarray:
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        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)
+        raw = cv2.HoughCircles(blurred, cv2.HOUGH_GRADIENT,
+                                dp=1.2, minDist=50, param1=50, param2=22,
+                                minRadius=self.DOOR_ARC_MIN_RADIUS,
+                                maxRadius=self.DOOR_ARC_MAX_RADIUS)
+        if raw is None:
+            return result
+        circles = np.round(raw[0]).astype(np.int32)
+        for cx, cy, r in circles:
+            angles, xs, ys = (np.linspace(0, 2*np.pi, 360, endpoint=False),
+                               None, None)
+            xs = np.clip((cx + r*np.cos(angles)).astype(np.int32), 0, w-1)
+            ys = np.clip((cy + r*np.sin(angles)).astype(np.int32), 0, h-1)
+            on_wall = binary[ys, xs] > 0
+            if not np.any(on_wall):
+                continue
+            occ = angles[on_wall]
+            span = float(np.degrees(occ[-1] - occ[0]))
+            if not (60 <= span <= 115):
+                continue
+            leaf_r = r * 0.92
+            n_pts = max(60, int(r))
+            la = np.linspace(0, 2*np.pi, n_pts, endpoint=False)
+            lx = np.clip((cx + leaf_r*np.cos(la)).astype(np.int32), 0, w-1)
+            ly = np.clip((cy + leaf_r*np.sin(la)).astype(np.int32), 0, h-1)
+            if float(np.mean(binary[ly, lx] > 0)) < 0.35:
+                continue
+            gap_thresh = np.radians(25.0)
+            diffs = np.diff(occ)
+            big = np.where(diffs > gap_thresh)[0]
+            if len(big) == 0:
+                start_a, end_a = occ[0], occ[-1]
+            else:
+                split = big[np.argmax(diffs[big])]
+                start_a, end_a = occ[split+1], occ[split]
+            ep1 = (int(round(cx + r*np.cos(start_a))),
+                   int(round(cy + r*np.sin(start_a))))
+            ep2 = (int(round(cx + r*np.cos(end_a))),
+                   int(round(cy + r*np.sin(end_a))))
+            ep1 = (np.clip(ep1[0],0,w-1), np.clip(ep1[1],0,h-1))
+            ep2 = (np.clip(ep2[0],0,w-1), np.clip(ep2[1],0,h-1))
+            cv2.line(result, ep1, ep2, (0,0,0), 3)
+        return result
+
+    # ── Stage 4: Extract walls ────────────────────────────────────────────────
+    def _extract_walls(self, img: np.ndarray) -> np.ndarray:
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        h, w = gray.shape
+
+        otsu_val, _ = cv2.threshold(gray, 0, 255,
+                                    cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+        brightness = float(np.mean(gray))
+        if brightness > 220:
+            thr = max(200, int(otsu_val * 1.1))
+        elif brightness < 180:
+            thr = max(150, int(otsu_val * 0.9))
+        else:
+            thr = int(otsu_val)
+
+        _, binary = cv2.threshold(gray, thr, 255, cv2.THRESH_BINARY_INV)
+
+        min_line = max(8, int(0.012 * w))
+        body_thickness = self._estimate_wall_thickness(binary)
+        body_thickness = int(np.clip(body_thickness, 9, 30))
+        self._wall_thickness = body_thickness
+
+        k_h = cv2.getStructuringElement(cv2.MORPH_RECT, (min_line, 1))
+        k_v = cv2.getStructuringElement(cv2.MORPH_RECT, (1, min_line))
+
+        if _GPU:
+            # GPU morphology via cupy — simulate with erosion+dilation
+            g_bin = _to_gpu(binary)
+            long_h = _to_cpu(cp.asarray(
+                cv2.morphologyEx(binary, cv2.MORPH_OPEN, k_h)))
+            long_v = _to_cpu(cp.asarray(
+                cv2.morphologyEx(binary, cv2.MORPH_OPEN, k_v)))
+        else:
+            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))
+        dilated_h = cv2.dilate(long_h, k_bh)
+        dilated_v = cv2.dilate(long_v, k_bv)
+        walls = cv2.bitwise_or(dilated_h, dilated_v)
+        collision = cv2.bitwise_and(dilated_h, dilated_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)
+        walls = self._thin_line_filter(walls, body_thickness)
+        n, labels, stats, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
+        if n > 1:
+            areas = stats[1:, cv2.CC_STAT_AREA]
+            min_noise = max(20, int(np.median(areas) * 0.0001))
+            lut = np.zeros(n, np.uint8)
+            lut[1:] = (areas >= min_noise).astype(np.uint8)
+            walls = (lut[labels] * 255).astype(np.uint8)
+        return walls
+
+    def _estimate_wall_thickness(self, binary: np.ndarray, fallback=12) -> int:
+        h, w = binary.shape
+        n_cols = min(200, w)
+        col_idx = np.linspace(0, w-1, n_cols, dtype=int)
+        runs = []
+        max_run = max(2, int(h * 0.05))
+        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 <= max_run)].tolist())
+        if runs:
+            return int(np.median(runs))
+        return fallback
+
+    def _thin_line_filter(self, walls: np.ndarray, min_thickness: int) -> np.ndarray:
+        dist = cv2.distanceTransform(walls, cv2.DIST_L2, 5)
+        thick_mask = dist >= (min_thickness / 2)
+        n, labels, _, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
+        if n <= 1:
+            return walls
+        thick_labels = labels[thick_mask]
+        if len(thick_labels) == 0:
+            return np.zeros_like(walls)
+        has_thick = np.zeros(n, dtype=bool)
+        has_thick[thick_labels] = True
+        lut = has_thick.astype(np.uint8) * 255
+        lut[0] = 0
+        return lut[labels]
+
+    # ── Stage 5b: Remove fixtures ─────────────────────────────────────────────
+    def _remove_fixtures(self, walls: np.ndarray) -> np.ndarray:
+        h, w = walls.shape
+        n, labels, stats, centroids = cv2.connectedComponentsWithStats(
+            walls, connectivity=8)
+        if n <= 1:
+            return walls
+        bw = stats[1:, cv2.CC_STAT_WIDTH].astype(np.float32)
+        bh = stats[1:, cv2.CC_STAT_HEIGHT].astype(np.float32)
+        ar = stats[1:, cv2.CC_STAT_AREA].astype(np.float32)
+        cx = np.round(centroids[1:, 0]).astype(np.int32)
+        cy = np.round(centroids[1:, 1]).astype(np.int32)
+        maxs = np.maximum(bw, bh)
+        mins = np.minimum(bw, bh)
+        asp  = maxs / (mins + 1e-6)
+        cand = ((bw < self.FIXTURE_MAX_BLOB_DIM) & (bh < self.FIXTURE_MAX_BLOB_DIM)
+                & (ar < self.FIXTURE_MAX_AREA) & (asp <= self.FIXTURE_MAX_ASPECT))
+        ci = np.where(cand)[0]
+        if len(ci) == 0:
+            return walls
+        heatmap = np.zeros((h, w), dtype=np.float32)
+        r_heat = int(self.FIXTURE_DENSITY_RADIUS)
+        for px, py in zip(cx[ci].tolist(), cy[ci].tolist()):
+            cv2.circle(heatmap, (px, py), r_heat, 1.0, -1)
+        blur_k = max(3, (r_heat // 2) | 1)
+        density = cv2.GaussianBlur(heatmap, (blur_k*4+1, blur_k*4+1), blur_k)
+        d_max = float(density.max())
+        if d_max > 0:
+            density /= d_max
+        zone = (density >= self.FIXTURE_DENSITY_THRESHOLD).astype(np.uint8) * 255
+        n_z, z_labels, z_stats, _ = cv2.connectedComponentsWithStats(zone)
+        clean = np.zeros_like(zone)
+        if n_z > 1:
+            za = z_stats[1:, cv2.CC_STAT_AREA]
+            kz = np.where(za >= self.FIXTURE_MIN_ZONE_AREA)[0] + 1
+            if len(kz):
+                lut = np.zeros(n_z, np.uint8)
+                lut[kz] = 255
+                clean = lut[z_labels]
+        zone = clean
+        valid = (cy[ci].clip(0,h-1) >= 0) & (cx[ci].clip(0,w-1) >= 0)
+        in_zone = valid & (zone[cy[ci].clip(0,h-1), cx[ci].clip(0,w-1)] > 0)
+        erase_ids = ci[in_zone] + 1
+        result = walls.copy()
+        if len(erase_ids):
+            lut = np.zeros(n, np.uint8)
+            lut[erase_ids] = 1
+            result[(lut[labels]).astype(bool)] = 0
+        return result
+
+    # ── Stage 5c: Calibrate + thin-line removal ────────────────────────────────
+    def _calibrate_wall(self, mask: np.ndarray) -> WallCalibration:
+        cal = WallCalibration()
+        h, w = mask.shape
+        n_cols = min(200, w)
+        col_idx = np.linspace(0, w-1, n_cols, dtype=int)
+        runs = []
+        max_run = max(2, int(h * 0.05))
+        for ci in col_idx:
+            col = (mask[:, 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 >= 1) & (r <= max_run)].tolist())
+        if runs:
+            arr  = np.array(runs, np.int32)
+            hist = np.bincount(np.clip(arr, 0, 200))
+            cal.stroke_width = max(2, int(np.argmax(hist[1:])) + 1)
+        cal.min_component_dim  = max(15, cal.stroke_width * 10)
+        cal.min_component_area = max(30, cal.stroke_width * cal.min_component_dim // 2)
+
+        gap_sizes = []
+        row_step = max(3, h // 200)
+        col_step = max(3, w // 200)
+        for row in range(5, h-5, row_step):
+            rd  = (mask[row, :] > 0).astype(np.int8)
+            pad = np.concatenate([[0], rd, [0]])
+            dif = np.diff(pad.astype(np.int16))
+            ends   = np.where(dif == -1)[0]
+            starts = np.where(dif ==  1)[0]
+            for e in ends:
+                nxt = starts[starts > e]
+                if len(nxt):
+                    g = int(nxt[0] - e)
+                    if 1 < g < 200:
+                        gap_sizes.append(g)
+        for col in range(5, w-5, col_step):
+            cd  = (mask[:, col] > 0).astype(np.int8)
+            pad = np.concatenate([[0], cd, [0]])
+            dif = np.diff(pad.astype(np.int16))
+            ends   = np.where(dif == -1)[0]
+            starts = np.where(dif ==  1)[0]
+            for e in ends:
+                nxt = starts[starts > e]
+                if len(nxt):
+                    g = int(nxt[0] - e)
+                    if 1 < g < 200:
+                        gap_sizes.append(g)
+
+        cal.bridge_min_gap = 2
+        if len(gap_sizes) >= 20:
+            g  = np.array(gap_sizes)
+            sm = g[g <= 30]
+            if len(sm) >= 10:
+                cal.bridge_max_gap = int(np.clip(np.percentile(sm, 75), 4, 20))
+            else:
+                cal.bridge_max_gap = cal.stroke_width * 4
+            door = g[(g > cal.bridge_max_gap) & (g <= 80)]
+            if len(door) >= 5:
+                raw = int(np.percentile(door, 90))
+            else:
+                raw = max(35, cal.stroke_width * 12)
+            raw = int(np.clip(raw, 25, 80))
+            cal.door_gap = raw if raw % 2 == 1 else raw + 1
+        cal.max_bridge_thick = cal.stroke_width * 5
+        self._wall_thickness  = cal.stroke_width
+        return cal
+
+    def _remove_thin_lines_calibrated(self, walls: np.ndarray) -> np.ndarray:
+        cal = self._wall_cal
+        n, cc, stats, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
+        if n <= 1:
+            return walls
+        bw = stats[1:, cv2.CC_STAT_WIDTH]
+        bh = stats[1:, cv2.CC_STAT_HEIGHT]
+        ar = stats[1:, cv2.CC_STAT_AREA]
+        mx = np.maximum(bw, bh)
+        keep = (mx >= cal.min_component_dim) | (ar >= cal.min_component_area * 3)
+        lut = np.zeros(n, np.uint8)
+        lut[1:] = keep.astype(np.uint8) * 255
+        return lut[cc]
+
+    # ── Stage 5d: Bridge endpoints ─────────────────────────────────────────────
+    def _skel(self, binary: np.ndarray) -> np.ndarray:
+        if _SKIMAGE:
+            return (_sk_skel(binary > 0) * 255).astype(np.uint8)
+        return self._morphological_skeleton(binary)
+
+    def _morphological_skeleton(self, 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 _tip_pixels(self, skel: np.ndarray):
+        sb  = (skel > 0).astype(np.float32)
+        nbr = cv2.filter2D(sb, -1, np.ones((3,3), np.float32),
+                            borderType=cv2.BORDER_CONSTANT)
+        return np.where((sb == 1) & (nbr.astype(np.int32) == 2))
+
+    def _outward_vectors(self, ex, ey, skel, lookahead):
+        n = len(ex)
+        odx = np.zeros(n, np.float32)
+        ody = np.zeros(n, np.float32)
+        sy, sx = np.where(skel > 0)
+        skel_set = set(zip(sx.tolist(), sy.tolist()))
+        D8 = [(-1,0),(1,0),(0,-1),(0,1),(-1,-1),(-1,1),(1,-1),(1,1)]
+        for i in range(n):
+            ox, oy = int(ex[i]), int(ey[i])
+            cx, cy = ox, oy
+            px, py = ox, oy
+            for _ in range(lookahead):
+                moved = False
+                for dx, dy in D8:
+                    nx_, ny_ = cx+dx, cy+dy
+                    if (nx_, ny_) == (px, py):
+                        continue
+                    if (nx_, ny_) in skel_set:
+                        px, py = cx, cy
+                        cx, cy = nx_, ny_
+                        moved = True
+                        break
+                if not moved:
+                    break
+            ix, iy = float(cx-ox), float(cy-oy)
+            nr = max(1e-6, np.hypot(ix, iy))
+            odx[i], ody[i] = -ix/nr, -iy/nr
+        return odx, ody
+
+    def _bridge_endpoints(self, walls: np.ndarray) -> np.ndarray:
+        cal    = self._wall_cal
+        result = walls.copy()
+        h, w   = walls.shape
+        FCOS   = np.cos(np.radians(70.0))
+        skel   = self._skel(walls)
+        ey, ex = self._tip_pixels(skel)
+        n_ep   = len(ey)
+        if n_ep < 2:
+            return result
+        _, cc_map = cv2.connectedComponents(walls, connectivity=8)
+        ep_cc = cc_map[ey, ex]
+        lookahead = max(8, cal.stroke_width * 3)
+        out_dx, out_dy = self._outward_vectors(ex, ey, skel, lookahead)
+        pts = np.stack([ex, ey], axis=1).astype(np.float32)
+        if _SCIPY:
+            pairs = cKDTree(pts).query_pairs(float(cal.bridge_max_gap), output_type='ndarray')
+            ii = pairs[:,0].astype(np.int64)
+            jj = pairs[:,1].astype(np.int64)
+        else:
+            _ii, _jj = np.triu_indices(n_ep, k=1)
+            ok = np.hypot(pts[_jj,0]-pts[_ii,0], pts[_jj,1]-pts[_ii,1]) <= cal.bridge_max_gap
+            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 <= 15.0
+        is_V = ang >= 75.0
+        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):
+            ia, ib = int(ii[pidx]), int(jj[pidx])
+            ax, ay = int(ex[ia]), int(ey[ia])
+            bx, by = int(ex[ib]), int(ey[ib])
+            if is_H[pidx]:
+                xs = np.linspace(ax, bx, N_SAMP, np.float32)
+                ys = np.full(N_SAMP, ay, np.float32)
+            else:
+                xs = np.full(N_SAMP, ax, np.float32)
+                ys = np.linspace(ay, by, N_SAMP, np.float32)
+            sxs  = np.clip(np.round(xs[1:-1]).astype(np.int32), 0, w-1)
+            sys_ = np.clip(np.round(ys[1:-1]).astype(np.int32), 0, h-1)
+            if np.any(walls[sys_, sxs] > 0):
+                clr[k] = False
+        valid = pre_idx[clr]
+        if len(valid) == 0:
+            return result
+        vi = ii[valid]; vj = jj[valid]
+        vd = dists[valid]; vH = is_H[valid]
+        order = np.argsort(vd)
+        vi, vj, vd, vH = vi[order], vj[order], vd[order], vH[order]
+        used  = np.zeros(n_ep, dtype=bool)
+        for k in range(len(vi)):
+            ia, ib = int(vi[k]), int(vj[k])
+            if used[ia] or used[ib]:
+                continue
+            ax, ay = int(ex[ia]), int(ey[ia])
+            bx, by = int(ex[ib]), int(ey[ib])
+            p1, p2 = ((min(ax,bx),ay),(max(ax,bx),ay)) if vH[k] \
+                else ((ax,min(ay,by)),(ax,max(ay,by)))
+            cv2.line(result, p1, p2, 255, cal.stroke_width)
+            used[ia] = used[ib] = True
+        return result
+
+    # ── Stage 5e: Close door openings ─────────────────────────────────────────
+    def _close_door_openings(self, walls: np.ndarray) -> np.ndarray:
+        cal = self._wall_cal
+        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)
+            new = cv2.bitwise_and(cls, cv2.bitwise_not(mask))
+            if not np.any(new):
+                return np.zeros_like(mask)
+            n, lbl, stats, _ = cv2.connectedComponentsWithStats(new, connectivity=8)
+            if n <= 1:
+                return np.zeros_like(mask)
+            perp = stats[1:, cv2.CC_STAT_HEIGHT if axis == 'H' else cv2.CC_STAT_WIDTH]
+            keep = perp <= max_thick
+            lut  = np.zeros(n, np.uint8)
+            lut[1:] = keep.astype(np.uint8) * 255
+            return lut[lbl]
+
+        add_h = _shape_close(walls, (gap,1), 'H', cal.max_bridge_thick)
+        add_v = _shape_close(walls, (1,gap), 'V', cal.max_bridge_thick)
+        return cv2.bitwise_or(walls, cv2.bitwise_or(add_h, add_v))
+
+    # ── Stage 5f: Remove dangling lines ───────────────────────────────────────
+    def _remove_dangling(self, walls: np.ndarray) -> np.ndarray:
+        stroke = self._wall_cal.stroke_width if self._wall_cal else self._wall_thickness
+        connect_radius = max(6, stroke * 3)
+        n, cc_map, stats, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
+        if n <= 1:
+            return walls
+        skel    = self._skel(walls)
+        tip_y, tip_x = self._tip_pixels(skel)
+        tip_cc  = cc_map[tip_y, tip_x]
+        free_counts = np.zeros(n, np.int32)
+        for i in range(len(tip_x)):
+            free_counts[tip_cc[i]] += 1
+        remove = np.zeros(n, dtype=bool)
+        for cc_id in range(1, n):
+            if free_counts[cc_id] < 2:
+                continue
+            bw_ = int(stats[cc_id, cv2.CC_STAT_WIDTH])
+            bh_ = int(stats[cc_id, cv2.CC_STAT_HEIGHT])
+            if max(bw_, bh_) > stroke * 40:
+                continue
+            comp = (cc_map == cc_id).astype(np.uint8)
+            dcomp = cv2.dilate(comp, cv2.getStructuringElement(
+                cv2.MORPH_ELLIPSE, (connect_radius*2+1, connect_radius*2+1)))
+            overlap = cv2.bitwise_and(
+                dcomp, ((walls > 0) & (cc_map != cc_id)).astype(np.uint8))
+            if np.count_nonzero(overlap) == 0:
+                remove[cc_id] = True
+        lut = np.ones(n, np.uint8); lut[0] = 0; lut[remove] = 0
+        return (lut[cc_map] * 255).astype(np.uint8)
+
+    # ── Stage 5g: Large gap closing ────────────────────────────────────────────
+    def _close_large_gaps(self, walls: np.ndarray) -> np.ndarray:
+        DOOR_MIN_GAP  = 180
+        DOOR_MAX_GAP  = 320
+        ANGLE_TOL_DEG = 12.0
+        FCOS = np.cos(np.radians(90.0 - ANGLE_TOL_DEG))
+        stroke = self._wall_cal.stroke_width if self._wall_cal else self._wall_thickness
+        line_width = max(stroke, 3)
+        result = walls.copy()
+        h, w   = walls.shape
+        skel   = self._skel(walls)
+        tip_y, tip_x = self._tip_pixels(skel)
+        n_ep = len(tip_x)
+        if n_ep < 2:
+            return result
+        _, cc_map = cv2.connectedComponents(walls, connectivity=8)
+        ep_cc = cc_map[tip_y, tip_x]
+        lookahead = max(12, stroke * 4)
+        out_dx, out_dy = self._outward_vectors(tip_x, tip_y, skel, lookahead)
+        pts = np.stack([tip_x, tip_y], axis=1).astype(np.float32)
+        if _SCIPY:
+            pairs = cKDTree(pts).query_pairs(float(DOOR_MAX_GAP), output_type='ndarray')
+            ii = pairs[:,0].astype(np.int64)
+            jj = pairs[:,1].astype(np.int64)
+        else:
+            _ii, _jj = np.triu_indices(n_ep, k=1)
+            ok = np.hypot(pts[_jj,0]-pts[_ii,0], pts[_jj,1]-pts[_ii,1]) <= DOOR_MAX_GAP
+            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_DEG
+        is_V = ang >= (90.0 - ANGLE_TOL_DEG)
+        g1 = (dists >= DOOR_MIN_GAP) & (dists <= DOOR_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  = 15
+        clr     = np.ones(len(pre_idx), dtype=bool)
+        for k, pidx in enumerate(pre_idx):
+            ia, ib = int(ii[pidx]), int(jj[pidx])
+            ax, ay = int(tip_x[ia]), int(tip_y[ia])
+            bx, by = int(tip_x[ib]), int(tip_y[ib])
+            if is_H[pidx]:
+                xs = np.linspace(ax, bx, N_SAMP, np.float32)
+                ys = np.full(N_SAMP, (ay+by)/2.0, np.float32)
+            else:
+                xs = np.full(N_SAMP, (ax+bx)/2.0, np.float32)
+                ys = np.linspace(ay, by, N_SAMP, np.float32)
+            sxs  = np.clip(np.round(xs[1:-1]).astype(np.int32), 0, w-1)
+            sys_ = np.clip(np.round(ys[1:-1]).astype(np.int32), 0, h-1)
+            if np.any(walls[sys_, sxs] > 0):
+                clr[k] = False
+        valid = pre_idx[clr]
+        if len(valid) == 0:
+            return result
+        vi = ii[valid]; vj = jj[valid]
+        vd = dists[valid]; vH = is_H[valid]
+        order = np.argsort(vd)
+        vi, vj, vd, vH = vi[order], vj[order], vd[order], vH[order]
+        used  = np.zeros(n_ep, dtype=bool)
+        for k in range(len(vi)):
+            ia, ib = int(vi[k]), int(vj[k])
+            if used[ia] or used[ib]:
+                continue
+            ax, ay = int(tip_x[ia]), int(tip_y[ia])
+            bx, by = int(tip_x[ib]), int(tip_y[ib])
+            if vH[k]:
+                p1 = (min(ax,bx),(ay+by)//2)
+                p2 = (max(ax,bx),(ay+by)//2)
+            else:
+                p1 = ((ax+bx)//2, min(ay,by))
+                p2 = ((ax+bx)//2, max(ay,by))
+            cv2.line(result, p1, p2, 255, line_width)
+            used[ia] = used[ib] = True
+        return result
+
+    # ── Stage 7: Flood-fill segmentation ─────────────────────────────────────
+    def _segment_rooms(self, walls: np.ndarray) -> np.ndarray:
+        h, w = walls.shape
+        walls = walls.copy()
+        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
+
+    # ── Stage 8: Filter room regions ─────────────────────────────────────────
+    def _filter_rooms(self, rooms_mask, img_shape):
+        h, w = img_shape[:2]
+        img_area = float(h * w)
+        min_area = img_area * self.MIN_ROOM_AREA_FRAC
+        max_area = img_area * self.MAX_ROOM_AREA_FRAC
+        min_dim  = w * self.MIN_ROOM_DIM_FRAC
+        margin   = max(5.0, w * self.BORDER_MARGIN_FRAC)
+        contours, _ = cv2.findContours(rooms_mask, cv2.RETR_EXTERNAL,
+                                        cv2.CHAIN_APPROX_SIMPLE)
+        if not contours:
+            return np.zeros_like(rooms_mask), []
+        valid_mask  = np.zeros_like(rooms_mask)
+        valid_rooms = []
+        for cnt in contours:
+            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 not (bw >= min_dim or bh >= min_dim):
+                continue
+            asp = max(bw,bh) / (min(bw,bh) + 1e-6)
+            if asp > self.MAX_ASPECT_RATIO:
+                continue
+            if (area / (bw*bh + 1e-6)) < self.MIN_EXTENT:
+                continue
+            hull = cv2.convexHull(cnt)
+            ha   = cv2.contourArea(hull)
+            if ha > 0 and (area / ha) < self.MIN_SOLIDITY:
+                continue
+            cv2.drawContours(valid_mask, [cnt], -1, 255, -1)
+            valid_rooms.append(cnt)
+        return valid_mask, valid_rooms
+
+    # ── Wand: click-to-segment ─────────────────────────────────────────────────
+    def wand_segment(self, walls: np.ndarray, click_x: int, click_y: int,
+                     existing_rooms: List[Dict]) -> Optional[Dict]:
+        """
+        Flood-fill from click point → return new room dict or None.
+        """
+        h, w = walls.shape
+        if not (0 <= click_x < w and 0 <= click_y < h):
+            return None
+        if walls[click_y, click_x] > 0:
+            return None  # clicked on a wall
+
+        # Build room-candidate mask from flood-fill
+        tmp = walls.copy()
+        tmp[:5,:] = 255; tmp[-5:,:] = 255
+        tmp[:,:5] = 255; tmp[:,-5:] = 255
+        filled = tmp.copy()
+        mask   = np.zeros((h+2, w+2), np.uint8)
+        # flood exterior
+        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(tmp))
+
+        # Flood-fill from click to isolate this room
+        if rooms[click_y, click_x] == 0:
+            return None
+
+        room_mask = np.zeros((h, w), np.uint8)
+        ff_mask   = rooms.copy()
+        fill_mask = np.zeros((h+2, w+2), np.uint8)
+        cv2.floodFill(ff_mask, fill_mask, (click_x, click_y), 128)
+        room_mask[ff_mask == 128] = 255
+
+        area = float(np.count_nonzero(room_mask))
+        if area < 100:
+            return None
+
+        contours, _ = cv2.findContours(room_mask, cv2.RETR_EXTERNAL,
+                                        cv2.CHAIN_APPROX_SIMPLE)
+        if not contours:
+            return None
+        cnt = max(contours, key=cv2.contourArea)
+        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
+
+        flat_seg = cnt[:,0,:].tolist()
+        flat_seg = [v for pt in flat_seg for v in pt]
+
+        new_id = max((r["id"] for r in existing_rooms), default=0) + 1
+        return {
+            "id"          : new_id,
+            "label"       : f"Room {new_id}",
+            "segmentation": [flat_seg],
+            "area"        : area,
+            "bbox"        : [bx, by, bw, bh],
+            "centroid"    : [cx, cy],
+            "confidence"  : 0.90,
+            "isWand"      : True,
+        }