3D check view: walls, slabs and their quantities

/** The mapping from PDF user space to the ground, in feet. */
export function sheetFrame(ftPerUnit, { transform = null, width = 0, height = 0 } = {}) {
  const T = transform || [1, 0, 0, -1, 0, height];
  const s = Math.sqrt(Math.abs(T[0] * T[3] - T[1] * T[2])) || 1;
  const k = ftPerUnit / s;
  return {
    k,
    w: width * k,
    h: height * k,
    /** {x, y} user space → [x, y] feet on the ground. */
    at: (p) => {
      const dx = T[0] * p.x + T[2] * p.y + T[4], dy = T[1] * p.x + T[3] * p.y + T[5];
      return [dx * k, (height - dy) * k];
    },
  };
}

const wallSqft = r.lengthFt * h;
totals.wallSqft += wallSqft; t.wallSqft += wallSqft; totals.walls++;
o = { ...base, kind: 'wall', tris, lines, anchor, measure: { lengthFt: r.lengthFt, heightFt: h, wallSqft, thickFt: thick, baseFt: z0, headFt: head } };

const thin = !(it.heightFt > 0);
const d = thin ? THIN_FT : it.heightFt;
const zb = it.baseFt > 0 ? it.baseFt : 0;                    // a ceiling or a raised floor (T5)
const mesh = prismMesh(outer, holes, zb, zb + d);
if (!mesh.triangulated) untriangulated++;
const net = Math.max(0, r.areaSqft - bo.cut(m, ftPerUnit) * r.factor);
const volumeCuft = thin ? null : net * d;
totals.netSqft += net; t.netSqft += net; t.count++;
if (thin) totals.plates++; else { totals.slabs++; totals.volumeCuft += volumeCuft; t.volumeCuft += volumeCuft; }

for (const k of Object.keys(totals)) totals[k] += r.totals[k];
for (const [id, v] of r.byItem) { const b = byItem.get(id); if (!b) byItem.set(id, { ...v }); else for (const k of Object.keys(v)) b[k] += v[k]; }

/**
 * A wall with a thickness (T5): the run offset half the thickness to each side (mitred joints, limited to 4× the half
 * width at sharp turns), closed into one outline and extruded from z0 to z1.
 */
export function wallOutline(run, thick) {
  const half = thick / 2, n = run.length;
  const dir = (a, b) => { const dx = b[0] - a[0], dy = b[1] - a[1], l = Math.hypot(dx, dy) || 1; return [dx / l, dy / l]; };
  const left = [], right = [];
  for (let i = 0; i < n; i++) {
    const d0 = i > 0 ? dir(run[i - 1], run[i]) : dir(run[0], run[1]);
    const d1 = i < n - 1 ? dir(run[i], run[i + 1]) : d0;
    let mx = -(d0[1] + d1[1]), my = d0[0] + d1[0];               // the bisector of the two left normals
    const ml = Math.hypot(mx, my);
    if (ml < 1e-9) { mx = -d0[1]; my = d0[0]; } else { mx /= ml; my /= ml; }
    const cos = mx * -d0[1] + my * d0[0];                         // between the bisector and the first segment's normal
    const k = Math.min(half / Math.max(cos, 1e-6), half * 4);
    left.push([run[i][0] + mx * k, run[i][1] + my * k]);
    right.push([run[i][0] - mx * k, run[i][1] - my * k]);
  }
  const ring = [...right, ...left.reverse()];
  return ringArea(ring) < 0 ? ring.reverse() : ring;
}

/** A prism: outline (CCW) minus holes (CW), from z0 to z1, closed and facing out. */
function prismMesh(outer, holes, z0, z1) {
  const tris = [], lines = [];
  const flat = [], holeIdx = [], all = [];
  for (const p of outer) { flat.push(p[0], p[1]); all.push(p); }
  for (const h of holes) { holeIdx.push(all.length); for (const p of h) { flat.push(p[0], p[1]); all.push(p); } }
  const idx = earcut(flat, holeIdx);
  for (let i = 0; i < idx.length; i += 3) {
    let a = all[idx[i]], b = all[idx[i + 1]], c = all[idx[i + 2]];
    if ((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]) < 0) [b, c] = [c, b];
    tris.push(a[0], a[1], z1, b[0], b[1], z1, c[0], c[1], z1);          // top, facing up
    tris.push(a[0], a[1], z0, c[0], c[1], z0, b[0], b[1], z0);          // bottom, facing down
  }
  for (const r of [outer, ...holes]) {
    for (let i = 0; i < r.length; i++) {
      const a = r[i], b = r[(i + 1) % r.length];
      quad(tris, a, b, z0, z1);                                           // outward: the ring runs with the solid on its left
      seg(lines, a, z0, b, z0); seg(lines, a, z1, b, z1);
    }
  }
  return { tris, lines, triangulated: idx.length > 0 };
}