opentakeoff-mcp 0.9.27 → 0.9.29

package/dist/server-core.js

@@ -1292,6 +1292,76 @@ function sweepHatchRuns(segs, meta, ws) {
   }
   return { clipSoft, runs };
 }
+var ANNOT_OFFSET_MAX_FT = 2;
+var ANNOT_OFFSET_MIN_FT = 0.25;
+var ANNOT_MIN_LEN_FT = 4;
+var ANNOT_OVERLAP_FRAC = 0.6;
+var ANNOT_MIN_PEN_STEP = 1;
+var ANNOT_MAX_SCAN = 64;
+function classifyOffsetAnnotationSegs(segs, meta, ws, maxOffsetPx, minOffsetPx, minLenPx) {
+  const n = segs.length >> 2;
+  const soft = new Uint8Array(n);
+  if (!meta || !n || !(maxOffsetPx > 0) || !(minLenPx > 0)) return soft;
+  const cand = [];
+  for (let i = 0; i < n; i++) {
+    const mt = meta[i];
+    if (mt & (SEG_CURVE | SEG_CLIP | SEG_FILLONLY)) continue;
+    const x1 = segs[i * 4] * ws, y1 = segs[i * 4 + 1] * ws, x2 = segs[i * 4 + 2] * ws, y2 = segs[i * 4 + 3] * ws;
+    const dx = x2 - x1, dy = y2 - y1;
+    if (Math.hypot(dx, dy) < minLenPx) continue;
+    let ang = Math.atan2(dy, dx) * 180 / Math.PI;
+    if (ang < 0) ang += 180;
+    if (ang >= 180) ang -= 180;
+    cand.push({ i, ang, x1, y1, x2, y2, w: meta[i] >> 4 });
+  }
+  if (cand.length < 2) return soft;
+  const BIN = HATCH_ANGLE_TOL, NBINS = Math.max(1, Math.round(180 / BIN));
+  for (const shift of [0, BIN / 2]) {
+    const bins = /* @__PURE__ */ new Map();
+    for (const c of cand) {
+      let b = Math.floor((c.ang + shift) / BIN);
+      if (b >= NBINS) b -= NBINS;
+      const th = c.ang * Math.PI / 180;
+      const dxu = Math.cos(th), dyu = Math.sin(th);
+      const nxu = -dyu, nyu = dxu;
+      const r = {
+        i: c.i,
+        ang: c.ang,
+        d: (c.x1 + c.x2) / 2 * nxu + (c.y1 + c.y2) / 2 * nyu,
+        t0: Math.min(c.x1 * dxu + c.y1 * dyu, c.x2 * dxu + c.y2 * dyu),
+        t1: Math.max(c.x1 * dxu + c.y1 * dyu, c.x2 * dxu + c.y2 * dyu),
+        w: c.w
+      };
+      const arr2 = bins.get(b);
+      if (arr2) arr2.push(r);
+      else bins.set(b, [r]);
+    }
+    for (const runs of bins.values()) {
+      if (runs.length < 2) continue;
+      runs.sort((a, b) => a.d - b.d);
+      for (let k = 0; k < runs.length; k++) {
+        const c = runs[k];
+        if (soft[c.i]) continue;
+        const need = ANNOT_OVERLAP_FRAC * (c.t1 - c.t0);
+        const alongside = (dir) => {
+          for (let step = 1, j = k + dir; step <= ANNOT_MAX_SCAN && j >= 0 && j < runs.length; step++, j += dir) {
+            const o = runs[j];
+            const gap = Math.abs(o.d - c.d);
+            if (gap > maxOffsetPx) break;
+            if (gap < minOffsetPx) continue;
+            if (Math.min(o.t1, c.t1) - Math.max(o.t0, c.t0) < need) continue;
+            return o;
+          }
+          return null;
+        };
+        const up = alongside(1), dn = alongside(-1);
+        const heavier = (o, other) => !!o && !other && o.w >= c.w + ANNOT_MIN_PEN_STEP;
+        if (heavier(up, dn) || heavier(dn, up)) soft[c.i] = 1;
+      }
+    }
+  }
+  return soft;
+}
 var HATCH_ID_ANGLE_Q = 0.5;
 var HATCH_ID_PITCH_Q = 0.1;
 function hatchFamilies(segs, meta) {
@@ -1335,6 +1405,10 @@ function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, pxPerFt
   const mask = new Uint8Array(mw * mh);
   const mppf = Number.isFinite(pxPerFt) && pxPerFt > 0 ? pxPerFt * ws : 0;
   const soft = meta ? classifyHatchSegs(segs, meta, ws, mppf > 0 ? HATCH_MAX_PITCH_FT * mppf : HATCH_MAX_PITCH) : null;
+  const annot = meta && mppf > 0 ? classifyOffsetAnnotationSegs(segs, meta, ws, ANNOT_OFFSET_MAX_FT * mppf, ANNOT_OFFSET_MIN_FT * mppf, ANNOT_MIN_LEN_FT * mppf) : null;
+  if (soft && annot) {
+    for (let i = 0; i < soft.length; i++) if (annot[i]) soft[i] = 1;
+  }
   const noDoor = meta ? flagNonDoorArcs(segs, meta) : null;
   let softCount = 0;
   for (let i = 0, si = 0; i + 3 < segs.length; i += 4, si++) {
@@ -1779,6 +1853,123 @@ function boundaryCurveClusters(mo, region) {
   }
   return clusters;
 }
+var SPLIT_GAP = 1;
+var SPLIT_MIN_SEED = 8;
+var SAME_ARC_CENTRE_FT = 0.5;
+var SAME_ARC_RADIUS_FRAC = 0.15;
+function splitMergedArcs(cl, mw, mask, mppf) {
+  if (cl.length < 2 * SPLIT_MIN_SEED) return [cl];
+  if (arcClusterFit(cl, mw, mask).good) return [cl];
+  const set = new Set(cl);
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const start of cl) {
+    if (seen.has(start)) continue;
+    seen.add(start);
+    const comp = [start];
+    const stack = [start];
+    while (stack.length) {
+      const i = stack.pop();
+      const y = i / mw | 0, x = i - y * mw;
+      for (let dy = -SPLIT_GAP; dy <= SPLIT_GAP; dy++) {
+        for (let dx = -SPLIT_GAP; dx <= SPLIT_GAP; dx++) {
+          if (!dx && !dy) continue;
+          const j = (y + dy) * mw + (x + dx);
+          if (set.has(j) && !seen.has(j)) {
+            seen.add(j);
+            comp.push(j);
+            stack.push(j);
+          }
+        }
+      }
+    }
+    parts.push(comp);
+  }
+  if (parts.length < 2) return [cl];
+  const centreTol = mppf > 0 ? Math.max(2, SAME_ARC_CENTRE_FT * mppf) : 4;
+  const groups = [];
+  const orphans = [];
+  for (const p of parts.slice().sort((a, b) => b.length - a.length)) {
+    const f = p.length >= SPLIT_MIN_SEED ? arcClusterFit(p, mw, mask) : null;
+    const claim = f && f.good ? groups.find((gp) => Math.hypot(gp.cx - f.cx, gp.cy - f.cy) <= centreTol && Math.abs(gp.r - f.r) <= SAME_ARC_RADIUS_FRAC * Math.max(gp.r, f.r)) : void 0;
+    if (claim) {
+      claim.cells.push(...p);
+      continue;
+    }
+    if (f && f.good) {
+      groups.push({ cx: f.cx, cy: f.cy, r: f.r, cells: p.slice() });
+      continue;
+    }
+    orphans.push(...p);
+  }
+  if (groups.length < 2) return [cl];
+  const out = groups.map((gp) => gp.cells);
+  if (orphans.length) out.push(orphans);
+  return out;
+}
+var LEAF_MIN_SECTOR_FRAC = 0.15;
+var LEAF_MIN_COVER = 0.55;
+var LEAF_HALF_FT = 0.3;
+var LEAF_HALF_FLOOR_PX = 1.5;
+var LEAF_T0 = 0.2;
+var LEAF_T1 = 0.95;
+function doorLeafCells(fit, cl, mw, mh, mask, mppf = 0) {
+  if (!fit.good || !(fit.r > 2)) return null;
+  const LEAF_HALF_W = mppf > 0 ? Math.max(LEAF_HALF_FLOOR_PX, LEAF_HALF_FT * mppf) : LEAF_HALF_FLOOR_PX;
+  const angs = cl.map((i) => Math.atan2((i / mw | 0) - fit.cy, i % mw - fit.cx)).sort((a, b) => a - b);
+  if (angs.length < 2) return null;
+  let gapAt = -1, gapMax = angs[0] + 2 * Math.PI - angs[angs.length - 1];
+  for (let k = 1; k < angs.length; k++) {
+    const gp = angs[k] - angs[k - 1];
+    if (gp > gapMax) {
+      gapMax = gp;
+      gapAt = k;
+    }
+  }
+  const ends = gapAt < 0 ? [angs[0], angs[angs.length - 1]] : [angs[gapAt], angs[gapAt - 1]];
+  let best = null, bestCover = LEAF_MIN_COVER;
+  for (const th of ends) {
+    const ux = Math.cos(th), uy = Math.sin(th);
+    const ax = fit.cx + ux * fit.r * LEAF_T0, ay = fit.cy + uy * fit.r * LEAF_T0;
+    const bx = fit.cx + ux * fit.r * LEAF_T1, by = fit.cy + uy * fit.r * LEAF_T1;
+    const x0 = Math.max(0, Math.floor(Math.min(ax, bx) - LEAF_HALF_W - 1));
+    const x1 = Math.min(mw - 1, Math.ceil(Math.max(ax, bx) + LEAF_HALF_W + 1));
+    const y0 = Math.max(0, Math.floor(Math.min(ay, by) - LEAF_HALF_W - 1));
+    const y1 = Math.min(mh - 1, Math.ceil(Math.max(ay, by) + LEAF_HALF_W + 1));
+    const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;
+    if (!(L2 > 0)) continue;
+    const cells = [];
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) {
+        let t = ((x - ax) * dx + (y - ay) * dy) / L2;
+        t = t < 0 ? 0 : t > 1 ? 1 : t;
+        const ex = ax + t * dx - x, ey = ay + t * dy - y;
+        if (ex * ex + ey * ey > LEAF_HALF_W * LEAF_HALF_W) continue;
+        const i = y * mw + x;
+        if (mask[i] & 1 && !(mask[i] & MASK_CURVE_BIT)) cells.push(i);
+      }
+    }
+    let hit = 0, tries = 0;
+    for (let t = 0; t <= 1; t += 0.02) {
+      tries++;
+      const px = ax + t * dx, py = ay + t * dy;
+      let inked = false;
+      for (let o = -LEAF_HALF_W; o <= LEAF_HALF_W && !inked; o += 0.5) {
+        const x = Math.round(px - dy / Math.sqrt(L2) * o), y = Math.round(py + dx / Math.sqrt(L2) * o);
+        if (x < 0 || y < 0 || x >= mw || y >= mh) continue;
+        const i = y * mw + x;
+        if (mask[i] & 1 && !(mask[i] & MASK_CURVE_BIT)) inked = true;
+      }
+      if (inked) hit++;
+    }
+    const cover = tries ? hit / tries : 0;
+    if (cover > bestCover && cells.length) {
+      bestCover = cover;
+      best = cells;
+    }
+  }
+  return best && best.length ? best : null;
+}
 function arcClusterFit(cl, mw, mask) {
   const m = cl.length;
   const X = (i) => i % mw, Y = (i) => i / mw | 0;
@@ -2009,10 +2200,33 @@ function floodRegionSealedInner(mo, ix, iy, sensitivity, radii, wedgeCapPx, minP
   let hatchTier = r1.hatchTier;
   let sealedPx = r1.sealedPx, virtualFrac = r1.virtualFrac;
   let minPassPxOut = r1.minPassPx, minPassDelta = r1.minPassDelta;
-  const ranked = clusters.map((cl) => {
+  const entry = (cl, pass, fit) => {
+    const f = fit ?? arcClusterFit(cl, mw, mo.mask);
+    const ideal = 0.5 * f.r * f.r * f.sweep;
+    return {
+      cl,
+      fit: f,
+      allow: wedgeAllowance(f, mo.mppf || 0, wedgeCapPx),
+      rank: doorLikeness(f, mo.mppf || 0),
+      at: cl[0],
+      pass,
+      minGrow: pass === 2 ? Math.max(1, Math.round(LEAF_MIN_SECTOR_FRAC * ideal)) : 0
+    };
+  };
+  const ranked = [];
+  for (const cl of clusters) {
     const fit = arcClusterFit(cl, mw, mo.mask);
-    return { cl, fit, allow: wedgeAllowance(fit, mo.mppf || 0, wedgeCapPx), rank: doorLikeness(fit, mo.mppf || 0), at: cl[0] };
-  }).filter((c) => c.allow >= 1).sort((a, b) => b.rank - a.rank || a.at - b.at);
+    ranked.push(entry(cl, 0, fit));
+    const parts = splitMergedArcs(cl, mw, mo.mask, mo.mppf || 0);
+    const pieces = parts.length > 1 ? parts : [cl];
+    if (parts.length > 1) for (const p of parts) ranked.push(entry(p, 1));
+    for (const p of pieces) {
+      const pf = p === cl ? fit : arcClusterFit(p, mw, mo.mask);
+      const leaf = doorLeafCells(pf, p, mw, mh, mo.mask, mo.mppf || 0);
+      if (leaf) ranked.push({ ...entry(leaf, 2, pf), cl: leaf });
+    }
+  }
+  ranked.splice(0, ranked.length, ...ranked.filter((c) => c.allow >= 1).sort((a, b) => a.pass - b.pass || b.rank - a.rank || a.at - b.at));
   let m2mask = null, m2dt = null;
   let openedCl = null, dirty = null;
   const rb1 = boxOf(r1.region, mw, mh);
@@ -2022,7 +2236,7 @@ function floodRegionSealedInner(mo, ix, iy, sensitivity, radii, wedgeCapPx, minP
     sealCache.set(mo.mask, base);
   }
   const baseDT = base.dt;
-  for (const { cl, fit, allow: clusterAllowance } of ranked.slice(0, WEDGE_MAX_DOORS)) {
+  for (const { cl, fit, allow: clusterAllowance, minGrow } of ranked.slice(0, 2 * WEDGE_MAX_DOORS)) {
     if (!m2mask) {
       m2mask = mo.mask.slice();
       m2dt = baseDT.slice();
@@ -2056,6 +2270,7 @@ function floodRegionSealedInner(mo, ix, iy, sensitivity, radii, wedgeCapPx, minP
     const r2 = sealAttempt(m2, sx, sy, sensitivity, radii, minPassPx, sc2);
     if (r2.status !== "ok" || r2.count <= r1.count) continue;
     const growth = r2.count - r1.count;
+    if (growth < minGrow) continue;
     if (growth > clusterAllowance) continue;
     if (count - r1.count + growth > globalAllowance) continue;
     if (!region) {
@@ -8945,7 +9160,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.27",
+  version: "0.9.29",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.27",
+  "version": "0.9.29",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",