Update app.py

app.py

@@ -129,36 +129,388 @@ def remove_colors(img: np.ndarray) -> np.ndarray:
     return result
 
 
-def estimate_wall_thickness(binary: np.ndarray, fallback: int = 12) -> int:
-    h, w = binary.shape
-    n_cols = min(200, w)
+# ════════════════════════════════════════════════════════════════════════════
+#  WALL CALIBRATION  (exact port from GeometryAgent WallCalibration)
+# ════════════════════════════════════════════════════════════════════════════
+
+from dataclasses import dataclass, field
+
+@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 calibrate_wall(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 = []
+    runs: List[int] = []
+    max_run = max(2, int(h * 0.05))
     for ci in col_idx:
-        col = (binary[:, ci] > 0).astype(np.int8)
+        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 >= 2) & (r <= h*0.15)].tolist())
+        runs.extend(r[(r >= 1) & (r <= max_run)].tolist())
     if runs:
-        return max(6, int(np.median(runs)))
+        arr  = np.array(runs, dtype=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: List[int] = []
+    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
+    return cal
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  SKELETON / TIP HELPERS
+# ════════════════════════════════════════════════════════════════════════════
+
+def _skel(binary: np.ndarray) -> np.ndarray:
+    try:
+        from skimage.morphology import skeletonize as _sk
+        return (_sk(binary > 0) * 255).astype(np.uint8)
+    except ImportError:
+        return _morphological_skeleton(binary)
+
+
+def _tip_pixels(skel_u8: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    sb  = (skel_u8 > 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(ex, ey, skel_u8: np.ndarray, lookahead: int):
+    n      = len(ex)
+    odx    = np.zeros(n, np.float32)
+    ody    = np.zeros(n, np.float32)
+    sy, sx = np.where(skel_u8 > 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:
+                nx2, ny2 = cx+dx, cy+dy
+                if (nx2, ny2) == (px, py): continue
+                if (nx2, ny2) in skel_set:
+                    px, py = cx, cy; cx, cy = nx2, ny2; moved = True; break
+            if not moved: break
+        ix, iy = float(cx-ox), float(cy-oy)
+        nr = max(1e-6, float(np.hypot(ix, iy)))
+        odx[i], ody[i] = -ix/nr, -iy/nr
+    return odx, ody
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  ANALYZE IMAGE CHARACTERISTICS  (brightness-aware threshold)
+# ════════════════════════════════════════════════════════════════════════════
+
+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)
+    if brightness > 220:
+        wall_threshold = max(200, int(otsu_thr * 1.1))
+    elif brightness < 180:
+        wall_threshold = max(150, int(otsu_thr * 0.9))
+    else:
+        wall_threshold = int(otsu_thr)
+    return {"brightness": brightness, "contrast": contrast,
+            "wall_threshold": wall_threshold, "otsu_threshold": otsu_thr}
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  DOOR ARC DETECTION  (exact port from GeometryAgent)
+# ════════════════════════════════════════════════════════════════════════════
+
+def detect_and_close_door_arcs(img: np.ndarray) -> np.ndarray:
+    R_MIN=60; R_MAX=320; DP=1.2; PARAM1=50; PARAM2=22; MIN_DIST=50
+    MAX_ARC=115.0; MIN_ARC=60.0; LEAF_FRAC=0.92; LEAF_THR=0.35
+    WALL_R=1.25; WALL_THR=12; SNAP_R=30
+    DOUBLE_R_RATIO=1.4; DOUBLE_DIST=1.8; LINE_T=3
+
+    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=DP, minDist=MIN_DIST,
+                           param1=PARAM1, param2=PARAM2, minRadius=R_MIN, maxRadius=R_MAX)
+    if raw is None:
+        return result
+
+    circles = np.round(raw[0]).astype(np.int32)
+
+    def sample_ring(cx, cy, r, n=360):
+        ang = np.linspace(0, 2*np.pi, n, endpoint=False)
+        xs  = np.clip((cx + r*np.cos(ang)).astype(np.int32), 0, w-1)
+        ys  = np.clip((cy + r*np.sin(ang)).astype(np.int32), 0, h-1)
+        return ang, xs, ys
+
+    def arc_span(cx, cy, r):
+        ang, xs, ys = sample_ring(cx, cy, r)
+        on = ang[binary[ys, xs] > 0]
+        if len(on) == 0: return 0.0, np.array([])
+        return float(np.degrees(on[-1]-on[0])), on
+
+    def has_leaf(cx, cy, r):
+        lr = r*LEAF_FRAC; n = max(60, int(r))
+        ang = np.linspace(0, 2*np.pi, n, endpoint=False)
+        xs = np.clip((cx+lr*np.cos(ang)).astype(np.int32), 0, w-1)
+        ys = np.clip((cy+lr*np.sin(ang)).astype(np.int32), 0, h-1)
+        return float(np.mean(binary[ys,xs]>0)) >= LEAF_THR
+
+    def wall_outside(cx, cy, r):
+        pr = r*WALL_R; ang = np.linspace(0, 2*np.pi, 36, endpoint=False)
+        xs = np.clip((cx+pr*np.cos(ang)).astype(np.int32), 0, w-1)
+        ys = np.clip((cy+pr*np.sin(ang)).astype(np.int32), 0, h-1)
+        return int(np.sum(binary[ys,xs]>0)) >= WALL_THR
+
+    def endpoints(cx, cy, r, occ):
+        gap_t = np.radians(25.0); diffs = np.diff(occ)
+        big = np.where(diffs > gap_t)[0]
+        if len(big) == 0: sa, ea = occ[0], occ[-1]
+        else:
+            sp = big[np.argmax(diffs[big])]
+            sa, ea = occ[sp+1], occ[sp]
+        def snap(a):
+            px2 = int(round(cx+r*np.cos(a))); py2 = int(round(cy+r*np.sin(a)))
+            y0=max(0,py2-SNAP_R); y1=min(h,py2+SNAP_R+1)
+            x0=max(0,px2-SNAP_R); x1=min(w,px2+SNAP_R+1)
+            roi = binary[y0:y1, x0:x1]
+            wy2, wx2 = np.where(roi>0)
+            if len(wx2)==0: return px2, py2
+            dd = np.hypot(wx2-(px2-x0), wy2-(py2-y0))
+            i  = int(np.argmin(dd))
+            return int(wx2[i]+x0), int(wy2[i]+y0)
+        return snap(sa), snap(ea)
+
+    valid = []
+    for cx, cy, r in circles:
+        span, occ = arc_span(cx, cy, r)
+        if not (MIN_ARC <= span <= MAX_ARC): continue
+        if not has_leaf(cx, cy, r): continue
+        if not wall_outside(cx, cy, r): continue
+        ep1, ep2 = endpoints(cx, cy, r, occ)
+        valid.append((cx, cy, r, ep1, ep2))
+
+    used = [False]*len(valid)
+    double_pairs = []
+    for i in range(len(valid)):
+        if used[i]: continue
+        cx1,cy1,r1,_,_ = valid[i]
+        best_j, best_d = -1, 1e9
+        for j in range(i+1, len(valid)):
+            if used[j]: continue
+            cx2,cy2,r2,_,_ = valid[j]
+            if max(r1,r2)/(min(r1,r2)+1e-6) > DOUBLE_R_RATIO: continue
+            cd = float(np.hypot(cx2-cx1, cy2-cy1))
+            if cd < (r1+r2)*DOUBLE_DIST and cd < best_d:
+                best_d, best_j = cd, j
+        if best_j >= 0:
+            double_pairs.append((i, best_j))
+            used[i] = used[best_j] = True
+
+    singles = [i for i in range(len(valid)) if not used[i]]
+    for idx in singles:
+        cx,cy,r,ep1,ep2 = valid[idx]
+        cv2.line(result, ep1, ep2, (0,0,0), LINE_T)
+    for i_idx, j_idx in double_pairs:
+        cx1,cy1,r1,ep1a,ep1b = valid[i_idx]
+        cx2,cy2,r2,ep2a,ep2b = valid[j_idx]
+        daa = np.hypot(ep1a[0]-ep2a[0], ep1a[1]-ep2a[1])
+        dab = np.hypot(ep1a[0]-ep2b[0], ep1a[1]-ep2b[1])
+        if daa <= dab: inner1,outer1,inner2,outer2 = ep1a,ep1b,ep2a,ep2b
+        else:          inner1,outer1,inner2,outer2 = ep1a,ep1b,ep2b,ep2a
+        cv2.line(result, outer1, outer2, (0,0,0), LINE_T)
+        cv2.line(result, inner1, inner2, (0,0,0), LINE_T)
+
+    return result
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  EXTRACT WALLS ADAPTIVE  (exact port — brightness-aware + double-line filter)
+# ════════════════════════════════════════════════════════════════════════════
+
+def _estimate_wall_body_thickness(binary: np.ndarray, fallback: int = 12) -> int:
+    h, w = binary.shape
+    n_cols  = min(200, w)
+    col_idx = np.linspace(0, w-1, n_cols, dtype=int)
+    cols    = (binary[:, col_idx] > 0).astype(np.int8)
+    padded  = np.concatenate([np.zeros((1,n_cols),np.int8), cols,
+                               np.zeros((1,n_cols),np.int8)], axis=0)
+    diff    = np.diff(padded.astype(np.int16), axis=0)
+    run_lengths = []
+    for ci in range(n_cols):
+        d = diff[:, ci]
+        s = np.where(d ==  1)[0]
+        e = np.where(d == -1)[0]
+        if len(s)==0 or len(e)==0: continue
+        r = e - s
+        r = r[(r >= 2) & (r <= h*0.15)]
+        if len(r): run_lengths.append(r)
+    if run_lengths:
+        return int(np.median(np.concatenate(run_lengths)))
     return fallback
 
 
-def extract_walls_adaptive(img_clean: np.ndarray) -> Tuple[np.ndarray, int]:
-    h, w   = img_clean.shape[:2]
-    gray   = cv2.cvtColor(img_clean, cv2.COLOR_BGR2GRAY)
-    otsu_t, binary = cv2.threshold(
-        gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU
-    )
-    wall_threshold = int(otsu_t)
+def _remove_thin_lines(walls: np.ndarray, min_thickness: int) -> np.ndarray:
+    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
+    thick_labels = labels[thick_mask]
+    if len(thick_labels) == 0: return np.zeros_like(walls)
+    has_thick = np.zeros(n_lbl, dtype=bool)
+    has_thick[thick_labels] = True
+    keep_lut = has_thick.astype(np.uint8)*255; keep_lut[0] = 0
+    return keep_lut[labels]
+
+
+def _filter_double_lines_and_thick(walls: np.ndarray) -> np.ndarray:
+    MIN_SINGLE_DIM = 20; DOUBLE_GAP = 60; DOUBLE_PCT = 12
+
+    n_lbl, labels, stats, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
+    if n_lbl <= 1: return walls
+
+    try:
+        skel_full = cv2.ximgproc.thinning(walls, thinningType=cv2.ximgproc.THINNING_ZHANGSUEN)
+    except AttributeError:
+        skel_full = _morphological_skeleton(walls)
+
+    skel_bin = skel_full > 0
+    keep_ids: set = set()
+    thin_cands = []
+
+    for i in range(1, n_lbl):
+        bw = int(stats[i, cv2.CC_STAT_WIDTH]); bh = int(stats[i, cv2.CC_STAT_HEIGHT])
+        if min(bw, bh) >= MIN_SINGLE_DIM: keep_ids.add(i)
+        else: thin_cands.append(i)
+
+    if not thin_cands:
+        filtered = np.zeros_like(walls)
+        for i in keep_ids: filtered[labels==i] = 255
+        return filtered
+
+    skel_labels = labels * skel_bin
+    img_h, img_w = labels.shape
+    probe_dists  = np.arange(3, DOUBLE_GAP+1, 3, dtype=np.float32)
+
+    for i in thin_cands:
+        bys, bxs = np.where(skel_labels == i)
+        if len(bys) < 4: continue
+        step = max(1, len(bys)//80)
+        sy = bys[::step].astype(np.float32); sx = bxs[::step].astype(np.float32)
+        n_s = len(sy)
+        sy_prev=np.roll(sy,1);  sy_prev[0]=sy[0]
+        sy_next=np.roll(sy,-1); sy_next[-1]=sy[-1]
+        sx_prev=np.roll(sx,1);  sx_prev[0]=sx[0]
+        sx_next=np.roll(sx,-1); sx_next[-1]=sx[-1]
+        dr=(sy_next-sy_prev); dc=(sx_next-sx_prev)
+        dlen=np.maximum(1.0, np.hypot(dr, dc))
+        pr=(-dc/dlen)[:,np.newaxis]; pc=(dr/dlen)[:,np.newaxis]
+        for sign in (1.0, -1.0):
+            rr = np.round(sy[:,np.newaxis] + sign*pr*probe_dists).astype(np.int32)
+            cc = np.round(sx[:,np.newaxis] + sign*pc*probe_dists).astype(np.int32)
+            valid_m = (rr>=0)&(rr<img_h)&(cc>=0)&(cc<img_w)
+            safe_rr = np.clip(rr, 0, img_h-1); safe_cc = np.clip(cc, 0, img_w-1)
+            lbl_at  = labels[safe_rr, safe_cc]
+            partner = valid_m & (lbl_at>0) & (lbl_at!=i)
+            hit_any = partner.any(axis=1)
+            hit_rows = np.where(hit_any)[0]
+            if len(hit_rows) == 0: continue
+            first_col = partner[hit_rows].argmax(axis=1)
+            partner_ids = lbl_at[hit_rows, first_col]
+            keep_ids.update(partner_ids.tolist())
+            if 100.0*len(hit_rows)/n_s >= DOUBLE_PCT:
+                keep_ids.add(i); break
+
+    if keep_ids:
+        ka = np.array(sorted(keep_ids), dtype=np.int32)
+        lut = np.zeros(n_lbl, dtype=np.uint8); lut[ka] = 255
+        return lut[labels]
+    return np.zeros_like(walls)
+
+
+def extract_walls_adaptive(img_clean: np.ndarray,
+                            img_stats: Optional[Dict] = None) -> Tuple[np.ndarray, int]:
+    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)
+        wall_threshold = int(otsu_t)
+
     _, binary = cv2.threshold(gray, wall_threshold, 255, cv2.THRESH_BINARY_INV)
 
     min_line_len   = max(8, int(0.012 * w))
-    body_thickness = estimate_wall_thickness(binary)
+    body_thickness = _estimate_wall_body_thickness(binary, fallback=12)
     body_thickness = int(np.clip(body_thickness, 9, 30))
 
     k_h = cv2.getStructuringElement(cv2.MORPH_RECT, (min_line_len, 1))
@@ -175,15 +527,13 @@ def extract_walls_adaptive(img_clean: np.ndarray) -> Tuple[np.ndarray, int]:
 
     collision = cv2.bitwise_and(dil_h, dil_v)
     safe_zone = cv2.bitwise_and(collision, orig_walls)
-    walls = cv2.bitwise_or(
-        cv2.bitwise_and(walls, cv2.bitwise_not(collision)), safe_zone
-    )
+    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
+    keep_mask = (dist <= body_thickness/2).astype(np.uint8) * 255
     walls     = cv2.bitwise_and(walls, keep_mask)
+    walls     = _remove_thin_lines(walls, min_thickness=body_thickness)
 
-    # noise removal
     n_lbl, labels, stats, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
     if n_lbl > 1:
         areas    = stats[1:, cv2.CC_STAT_AREA]
@@ -192,9 +542,272 @@ def extract_walls_adaptive(img_clean: np.ndarray) -> Tuple[np.ndarray, int]:
         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
+
     return walls, body_thickness
 
 
+# ════════════════════════════════════════════════════════════════════════════
+#  REMOVE FIXTURE SYMBOLS  (exact port from GeometryAgent)
+# ════════════════════════════════════════════════════════════════════════════
+
+FIXTURE_MAX_BLOB=80; FIXTURE_MAX_AREA=4000; FIXTURE_MAX_ASP=4.0
+FIXTURE_DENSITY_R=50; FIXTURE_DENSITY_THR=0.35; FIXTURE_MIN_ZONE=1500
+
+def remove_fixture_symbols(walls: np.ndarray) -> np.ndarray:
+    h, w = walls.shape
+    n_lbl, labels, stats, centroids = cv2.connectedComponentsWithStats(walls, connectivity=8)
+    if n_lbl <= 1: return walls
+
+    bw_a=stats[1:,cv2.CC_STAT_WIDTH].astype(np.float32)
+    bh_a=stats[1:,cv2.CC_STAT_HEIGHT].astype(np.float32)
+    ar_a=stats[1:,cv2.CC_STAT_AREA].astype(np.float32)
+    cx_a=np.round(centroids[1:,0]).astype(np.int32)
+    cy_a=np.round(centroids[1:,1]).astype(np.int32)
+    mx=np.maximum(bw_a,bh_a); mn=np.minimum(bw_a,bh_a)
+    asp=mx/(mn+1e-6)
+    cand=(bw_a<FIXTURE_MAX_BLOB)&(bh_a<FIXTURE_MAX_BLOB)&(ar_a<FIXTURE_MAX_AREA)&(asp<=FIXTURE_MAX_ASP)
+    ci=np.where(cand)[0]; cand_ids=ci+1; ccx=cx_a[ci]; ccy=cy_a[ci]
+
+    if len(cand_ids)==0: return walls
+    heatmap=np.zeros((h,w),dtype=np.float32)
+    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)
+    dm=float(density.max())
+    if dm>0: density/=dm
+    zone=(density>=FIXTURE_DENSITY_THR).astype(np.uint8)*255
+    nz,zlbl,zst,_=cv2.connectedComponentsWithStats(zone,connectivity=8)
+    cz=np.zeros_like(zone)
+    if nz>1:
+        za=zst[1:,cv2.CC_STAT_AREA]; kz=np.where(za>=FIXTURE_MIN_ZONE)[0]+1
+        if len(kz):
+            lut2=np.zeros(nz,dtype=np.uint8); lut2[kz]=255; cz=lut2[zlbl]
+    zone=cz
+    vc=(ccy>=0)&(ccy<h)&(ccx>=0)&(ccx<w)
+    in_zone=vc&(zone[ccy.clip(0,h-1), ccx.clip(0,w-1)]>0)
+    erase_ids=cand_ids[in_zone]
+    result=walls.copy()
+    if len(erase_ids):
+        el=np.zeros(n_lbl,dtype=np.uint8); el[erase_ids]=1
+        result[el[labels].astype(bool)]=0
+    return result
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  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:
+    n_cc, cc, stats, _ = cv2.connectedComponentsWithStats(walls, connectivity=8)
+    if n_cc <= 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_cc,np.uint8); lut[1:]=keep.astype(np.uint8)*255
+    return lut[cc]
+
+
+def _bridge_wall_endpoints_v2(walls: np.ndarray, cal: WallCalibration,
+                               angle_tol: float = 15.0) -> np.ndarray:
+    try:
+        from scipy.spatial import cKDTree as _KDTree
+        _SCIPY = True
+    except ImportError:
+        _SCIPY = False
+
+    result=walls.copy(); h,w=walls.shape; FCOS=np.cos(np.radians(70.0))
+    skel=_skel(walls); ey,ex=_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=_outward_vectors(ex,ey,skel,lookahead)
+    pts=np.stack([ex,ey],axis=1).astype(np.float32)
+
+    if _SCIPY:
+        from scipy.spatial import cKDTree
+        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<=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):
+        ia,ib=int(ii[pidx]),int(jj[pidx])
+        ax,ay=int(ex[ia]),int(ey[ia]); bx2,by2=int(ex[ib]),int(ey[ib])
+        if is_H[pidx]:
+            xs=np.linspace(ax,bx2,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,by2,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]); bx2,by2=int(ex[ib]),int(ey[ib])
+        p1,p2=((min(ax,bx2),ay),(max(ax,bx2),ay)) if vH[k] else ((ax,min(ay,by2)),(ax,max(ay,by2)))
+        cv2.line(result,p1,p2,255,cal.stroke_width)
+        used[ia]=used[ib]=True
+    return result
+
+
+def _close_door_openings_v2(walls: np.ndarray, cal: WallCalibration) -> np.ndarray:
+    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)
+        n2,lbl2,st2,_=cv2.connectedComponentsWithStats(new,connectivity=8)
+        if n2<=1: return np.zeros_like(mask)
+        perp=st2[1:,cv2.CC_STAT_HEIGHT if axis=='H' else cv2.CC_STAT_WIDTH]
+        keep=perp<=max_thick; lut2=np.zeros(n2,np.uint8); lut2[1:]=keep.astype(np.uint8)*255
+        return lut2[lbl2]
+    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))
+
+
+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)
+    walls = _close_door_openings_v2(walls, cal)
+    return walls, cal
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  REMOVE DANGLING LINES  (exact port from GeometryAgent)
+# ════════════════════════════════════════════════════════════════════════════
+
+def remove_dangling_lines(walls: np.ndarray, cal: WallCalibration) -> np.ndarray:
+    stroke = cal.stroke_width
+    connect_radius = max(6, stroke*3)
+    n_cc,cc_map,stats,_ = cv2.connectedComponentsWithStats(walls,connectivity=8)
+    if n_cc <= 1: return walls
+
+    skel=_skel(walls); tip_y,tip_x=_tip_pixels(skel)
+    tip_cc=cc_map[tip_y,tip_x]
+    free_counts=np.zeros(n_cc,dtype=np.int32)
+    for i in range(len(tip_x)): free_counts[tip_cc[i]]+=1
+
+    remove=np.zeros(n_cc,dtype=bool)
+    ker=cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(connect_radius*2+1,connect_radius*2+1))
+    for cc_id in range(1,n_cc):
+        if free_counts[cc_id]<2: continue
+        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)
+        overlap=cv2.bitwise_and(dc,((walls>0)&(cc_map!=cc_id)).astype(np.uint8))
+        if np.count_nonzero(overlap)==0: remove[cc_id]=True
+
+    lut=np.ones(n_cc,dtype=np.uint8); lut[0]=0; lut[remove]=0
+    return (lut[cc_map]*255).astype(np.uint8)
+
+
+# ════════════════════════════════════════════════════════════════════════════
+#  CLOSE LARGE DOOR GAPS  (exact port from GeometryAgent 180–320px)
+# ════════════════════════════════════════════════════════════════════════════
+
+def close_large_door_gaps(walls: np.ndarray, cal: WallCalibration) -> np.ndarray:
+    try:
+        from scipy.spatial import cKDTree
+        _SCIPY = True
+    except ImportError:
+        _SCIPY = False
+
+    DOOR_MIN=180; DOOR_MAX=320; ANGLE_TOL=12.0
+    FCOS=np.cos(np.radians(90.0-ANGLE_TOL))
+    stroke=cal.stroke_width; line_width=max(stroke,3)
+    result=walls.copy(); h,w=walls.shape
+
+    skel=_skel(walls); tip_y,tip_x=_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=_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),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
+        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]
+
+    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]); bx2,by2=int(tip_x[ib]),int(tip_y[ib])
+        if is_H[pidx]:
+            xs=np.linspace(ax,bx2,N_SAMP,dtype=np.float32)
+            ys=np.full(N_SAMP,(ay+by2)/2.0,dtype=np.float32)
+        else:
+            xs=np.full(N_SAMP,(ax+bx2)/2.0,dtype=np.float32)
+            ys=np.linspace(ay,by2,N_SAMP,dtype=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]); bx2,by2=int(tip_x[ib]),int(tip_y[ib])
+        if vH[k]: p1=(min(ax,bx2),(ay+by2)//2); p2=(max(ax,bx2),(ay+by2)//2)
+        else:     p1=((ax+bx2)//2,min(ay,by2)); p2=((ax+bx2)//2,max(ay,by2))
+        cv2.line(result,p1,p2,255,line_width)
+        used[ia]=used[ib]=True
+    return result
+
+
 def apply_user_lines_to_walls(
     walls: np.ndarray,
     lines: List[Tuple[int,int,int,int]],
@@ -588,6 +1201,8 @@ def init_state() -> Dict:
         "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,
@@ -639,19 +1254,46 @@ def cb_preprocess(state):
     if img is None:
         return None, None, state, "Load an image first."
 
+    # ── Step 1: crop title block ──────────────────────────────────────────
     cropped = remove_title_block(img)
-    clean   = remove_colors(cropped)
 
-    state["img_cropped"] = cropped
-    state["img_clean"]   = clean
+    # ── Step 2: remove CAD colours ────────────────────────────────────────
+    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)
 
-    walls, thick = extract_walls_adaptive(clean)
+    # ── 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(clean, cv2.COLOR_BGR2RGB)
-    return clean_rgb, walls_rgb, state, f"✅ Walls extracted  (thickness≈{thick}px)"
+    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")
+    return clean_rgb, walls_rgb, state, msg
 
 
 def cb_add_door_line(evt: gr.SelectData, state):
@@ -698,16 +1340,12 @@ def cb_undo_door_line(state):
     state["user_lines"].pop()
     state["draw_start"] = None
 
-    walls = state.get("walls")
-    img   = state.get("img_clean")
-    if walls is None:
+    walls_base = state.get("walls_base")
+    if walls_base is None:
         return None, state, "Re-run preprocessing."
 
-    # recompute from scratch
-    walls_base, thick = extract_walls_adaptive(state["img_clean"])
-    walls_upd = apply_user_lines_to_walls(
-        walls_base, state["user_lines"], thick
-    )
+    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)