Foundation parts and quantities

/**
 * Footing width and depth (mm) — labelled defaults after the usual light-frame table for 1500 psf soil (a slab or stem-wall
 * slab 12" / 15" / 23" wide for 1 / 2 / 3 stories; with a crawlspace or basement 18" / 22" / 27"); 4" wider under masonry or
 * concrete walls; 8" deep, 10" from 24" wide. A designer or engineer checks them for the soil and loads.
 */
export function footingSize({ kind = 'stemslab', stories = 1, heavy = false } = {}) {
  const n = Math.max(1, Math.min(3, Math.round(stories)));
  const base = (kind === 'crawl' || kind === 'basement' ? [18, 22, 27] : [12, 15, 23])[n - 1] + (heavy ? 4 : 0);
  return { width: base * IN, depth: (base >= 24 ? 10 : 8) * IN };
}

export function insetPoly(P, d) {
  const n = P.length, E = P.map((a, i) => { const b = P[(i + 1) % n], L = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1, u = [(b[0] - a[0]) / L, (b[1] - a[1]) / L]; return { a, u, n: [-u[1], u[0]] }; });
  return E.map((e, i) => {
    const f = E[(i + n - 1) % n];
    const p0 = [f.a[0] + f.n[0] * d, f.a[1] + f.n[1] * d], p1 = [e.a[0] + e.n[0] * d, e.a[1] + e.n[1] * d];
    const c = cross(f.u, e.u);
    if (Math.abs(c) < 1e-9) return p1;
    const t = cross(sub(p1, p0), e.u) / c;
    return [p0[0] + f.u[0] * t, p0[1] + f.u[1] * t];
  });
}

/** The parts of a foundation under `outline` (anticlockwise outer faces), heights from the floor. With `grade` (a function
 *  of plan x, y → the ground's height from the floor), stem walls and crawlspace footings step down to follow it. */
export function foundationGeometry(outline, p, { grade = null } = {}) {
  const parts = [];
  if (grade && (p.kind === 'stemslab' || p.kind === 'crawl')) {
    parts.push(...steppedRings(outline, p, grade));
    if (p.kind === 'stemslab') { const poly = insetPoly(outline, p.stemT); if (area(poly) > 1e4) parts.push({ role: 'slab', outer: poly, inner: null, z0: -p.slabT, z1: 0 }); }
    return parts;
  }
  const ring = (role, dOut, dIn, z0, z1) => { const outer = insetPoly(outline, dOut), inner = insetPoly(outline, dIn); if (area(inner) > 1e4 && z1 > z0) parts.push({ role, outer, inner, z0, z1 }); };
  const slab = (d, z0, z1) => { const poly = insetPoly(outline, d); if (area(poly) > 1e4) parts.push({ role: 'slab', outer: poly, inner: null, z0, z1 }); };
  const footUnder = (top) => ring('footing', (p.stemT - p.footW) / 2, (p.stemT + p.footW) / 2, top - p.footD, top);
  if (p.kind === 'slab') {
    slab(0, -p.slabT, 0);
    ring('edge', 0, p.edgeW, -p.edgeD, -p.slabT);
  } else if (p.kind === 'stemslab' || p.kind === 'crawl') {
    const footTop = -p.bottom + p.footD;
    ring('stem', 0, p.stemT, footTop, p.stemTop);
    footUnder(footTop);
    if (p.kind === 'stemslab') slab(p.stemT, -p.slabT, 0);
  } else if (p.kind === 'basement') {
    const slabTop = p.stemTop - p.basementH, footTop = slabTop - p.slabT;
    ring('stem', 0, p.stemT, footTop, p.stemTop);
    footUnder(footTop);
    slab(p.stemT, slabTop - p.slabT, slabTop);
  }
  return parts;
}

/**
 * Stem walls and footings stepped to the grade: each wall's strip of the rings split into runs where the footing's underside
 * (the grade along the outside of the wall − `bottom`) falls in another 8" step. grade(x, y) → z from the floor, or null.
 */
function steppedRings(outline, p, grade) {
  const parts = [];
  const n = outline.length;
  const sO = outline, sI = insetPoly(outline, p.stemT), fO = insetPoly(outline, (p.stemT - p.footW) / 2), fI = insetPoly(outline, (p.stemT + p.footW) / 2);
  for (let i = 0; i < n; i++) {
    const a = outline[i], b = outline[(i + 1) % n], L = Math.hypot(b[0] - a[0], b[1] - a[1]);
    if (L < 1) continue;
    const u = [(b[0] - a[0]) / L, (b[1] - a[1]) / L];
    const quad = (O, I) => [O[i], O[(i + 1) % n], I[(i + 1) % n], I[i]];
    const stemQ = quad(sO, sI), footQ = quad(fO, fI);
    // the needed underside along the wall, in steps; runs of the same step
    // the footing's underside `bottom` below the grade there (where the ground is missing: 8" under the floor), in whole steps
    const at = (s) => { const g = grade(a[0] + u[0] * s, a[1] + u[1] * s); return Math.floor(((g ?? -200) - p.bottom) / STEP) * STEP; };
    const ss = [];
    for (let s = 0; s <= L; s += 600) ss.push(s);
    if (ss[ss.length - 1] < L) ss.push(L);
    let r0 = 0, z0 = Math.min(at(0), -p.bottom);
    const runs = [];
    for (let k = 1; k < ss.length; k++) { const z = Math.min(at(ss[k]), -p.bottom); if (z !== z0) { const m = (ss[k - 1] + ss[k]) / 2; runs.push([r0, m, z0]); r0 = m; z0 = z; } }
    runs.push([r0, L, z0]);
    for (const [s0, s1, zb] of runs) {
      const lo = runs.length === 1 ? -1e9 : s0, hi = runs.length === 1 ? 1e9 : s1;
      const fq = band(footQ, a, u, s0 === 0 ? -1e9 : lo, s1 === L ? 1e9 : hi), sq = band(stemQ, a, u, s0 === 0 ? -1e9 : lo, s1 === L ? 1e9 : hi);
      if (fq.length >= 3) parts.push({ role: 'footing', outer: fq, inner: null, z0: zb, z1: zb + p.footD, step: true });
      if (sq.length >= 3 && p.stemTop > zb + p.footD) parts.push({ role: 'stem', outer: sq, inner: null, z0: zb + p.footD, z1: p.stemTop, step: true });
    }
  }
  return parts;
}

/** Keep the part of a polygon between two lines square to u at s0 and s1 (measured from o). */
function band(poly, o, u, s0, s1) {
  const clip = (P, sgn, c) => {
    const out = [], f = (q) => sgn * ((q[0] - o[0]) * u[0] + (q[1] - o[1]) * u[1] - c);
    for (let i = 0; i < P.length; i++) { const a = P[i], b = P[(i + 1) % P.length], fa = f(a), fb = f(b); if (fa >= -1e-9) out.push(a); if ((fa < -1e-9 && fb > 1e-9) || (fa > 1e-9 && fb < -1e-9)) { const t = fa / (fa - fb); out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]); } }
    return out;
  };
  return clip(clip(poly, 1, s0), -1, s1);
}

grade = (x, y) => { const q = apply(x, y), g = groundAt(w, q[0], q[1]); return g === null ? null : g - M[14]; };

const a = Math.abs(area(g.outer)) - (g.inner ? Math.abs(area(g.inner)) : 0), h = g.z1 - g.z0;
if (g.role === 'slab') w.upsertQto(id, 'Qto_SlabBaseQuantities', [['Width', 'length', h], ['Perimeter', 'length', perim(g.outer)], ['GrossArea', 'area', a], ['NetArea', 'area', a], ['GrossVolume', 'volume', a * h], ['NetVolume', 'volume', a * h]]);
else {
  const len = (perim(g.outer) + perim(g.inner)) / 2, width = a / len;

const vol = pieces.reduce((sum, q) => sum + Math.abs(area(q.outer)) * (q.z1 - q.z0), 0);
const len = pieces.reduce((sum, q) => sum + perim(q.outer) / 2, 0);