Plan view: picked points, wall outlines and dimensions

/**
 * Dimensions for the drawn walls of a level (BM.7): each wall's length along one face — the outside face of an outside
 * wall, else its left face — and, when it holds doors or windows, a chain from the face's ends to each opening's edges
 * nearer the wall. → [{ a, b, text, offPx, offMm, key }] (a, b on the face; offPx / offMm how far out to draw it on screen
 * and on paper; the sign puts it on the face's side). fmt(mm) gives the text.
 */
export function wallDims(walls, outlines, openings, fmt, { exteriorOf = () => true } = {}) {
  const out = [];
  for (const w of walls) {
    const poly = outlines.get(w.guid);
    if (!poly) continue;
    const L = Math.hypot(w.b[0] - w.a[0], w.b[1] - w.a[1]);
    if (L < 1 || w.bulge) continue;   // a curved wall's length is in its Properties (no arc dimension yet)
    const u = [(w.b[0] - w.a[0]) / L, (w.b[1] - w.a[1]) / L], n = [-u[1], u[0]];
    const side = exteriorOf(w) ? (w.extSide === 'right' ? -1 : 1) : 1;
    const local = poly.map(([x, y]) => [(x - w.a[0]) * u[0] + (y - w.a[1]) * u[1], (x - w.a[0]) * n[0] + (y - w.a[1]) * n[1]]);
    const xs = local.filter(([, y]) => Math.abs(y - side * w.t / 2) < 0.5).map(([x]) => x);
    if (xs.length < 2) continue;
    const e0 = Math.min(...xs), e1 = Math.max(...xs);
    const P = (x) => [w.a[0] + u[0] * x + n[0] * side * w.t / 2, w.a[1] + u[1] * x + n[1] * side * w.t / 2];
    const mine = openings.filter((o) => o.wall === w.id).sort((a, b) => a.offset - b.offset);
    const stops = [e0];
    for (const o of mine) stops.push(Math.max(e0, o.offset), Math.min(e1, o.offset + o.width));
    stops.push(e1);
    const s = [...new Set(stops.map((x) => Math.round(x * 100) / 100))].sort((a, b) => a - b);
    if (mine.length) for (let i = 0; i + 1 < s.length; i++) if (s[i + 1] - s[i] > 0.5) out.push({ a: P(s[i]), b: P(s[i + 1]), text: fmt(s[i + 1] - s[i]), offPx: side * 22, offMm: side * 5, key: w.id });
    out.push({ a: P(e0), b: P(e1), text: fmt(e1 - e0), offPx: side * (mine.length ? 44 : 22), offMm: side * (mine.length ? 10 : 5), key: w.id });
  }
  return out;
}

/**
 * A drawn wall's plan: its joined outline (plan points) with the openings the cut plane passes through taken out.
 * openings: [{ offset (along the wall from its start, mm, to the opening's near edge), width, sill, height }] (sill and the
 * cut height both above the level's floor).
 * → [[x, y]…][] (one polygon, or several pieces between openings)
 */
export function wallPieces(wall, poly, openings = [], cutZ = 1200) {
  const ang = Math.atan2(wall.b[1] - wall.a[1], wall.b[0] - wall.a[0]), c = Math.cos(ang), s = Math.sin(ang);
  let toL = ([x, y]) => [(x - wall.a[0]) * c + (y - wall.a[1]) * s, -(x - wall.a[0]) * s + (y - wall.a[1]) * c];
  let toW = ([u, v]) => [wall.a[0] + u * c - v * s, wall.a[1] + u * s + v * c];
  // a curved wall: along its arc and across it (polar), so openings are cut along the radius as in 3D
  if (wall.bulge) ({ toL, toW } = wallMap(wall));
  let pieces = [poly.map(toL)];
  for (const o of openings) {
    if (!(o.width > 0) || cutZ < o.sill || cutZ > o.sill + o.height) continue;   // both above the level's floor
    const next = [];
    for (const p of pieces) {
      const l = clipX(p, o.offset, -1), r = clipX(p, o.offset + o.width, 1);
      if (l.length >= 3) next.push(l);
      if (r.length >= 3) next.push(r);
    }
    pieces = next;
  }
  return pieces.map((p) => p.map(toW));
}

/** Keep the part of a polygon with x ≤ k (side −1) or x ≥ k (side 1): Sutherland–Hodgman against one line. */
function clipX(p, k, side) {
  const inside = (q) => (side < 0 ? q[0] <= k + 1e-9 : q[0] >= k - 1e-9);
  const out = [];
  for (let i = 0; i < p.length; i++) {
    const a = p[i], b = p[(i + 1) % p.length];
    const ia = inside(a), ib = inside(b);
    if (ia) out.push(a);
    if (ia !== ib) { const t = (k - a[0]) / (b[0] - a[0]); out.push([k, a[1] + (b[1] - a[1]) * t]); }
  }
  return out;
}

/** viewer (Y up, m) → model mm (Z up, file axes) → storey plan (mm). */
export function viewerToPlan(C, storeyWorldMm) {
  const S = [1000, 0, 0, 0, 0, 0, 1000, 0, 0, -1000, 0, 0, 0, 0, 0, 1];
  return mul4(inv4(storeyWorldMm), mul4(S, inv4(C)));
}

fromCanvas(px, py) { return [(px - this.w / 2) / this.scale + this.cx, (this.h2 / 2 - py) / this.scale + this.cy]; }