Wall faces and plan frames from element meshes

/** Faces of the walls on a storey (or every wall), as plan segments in model mm. */
wallFaces(storey = null) {
  const so = this.storeyOf(), out = [];
  const C = this.api.GetCoordinationMatrix(this.mid);
  const Ci = inv4(C);
  let walls = [];
  try { walls = ids(this.api, this.mid, 'IFCWALL', true); } catch (e) { walls = []; }
  if (!walls.length) walls = [...ids(this.api, this.mid, 'IFCWALL'), ...ids(this.api, this.mid, 'IFCWALLSTANDARDCASE')];
  for (const w of new Set(walls)) {
    if (storey !== null && so.get(w) !== storey) continue;
    let tri;
    try { tri = productTriangles(this.api, this.mid, w, this.unitMm, Ci); } catch (e) { continue; }
    const pts = [];
    for (let i = 0; i < tri.positions.length; i += 3) pts.push([tri.positions[i] * this.unitMm, tri.positions[i + 1] * this.unitMm]);
    const rect = minAreaRect(pts);
    if (!rect) continue;
    const [p0, p1, p2, p3] = rect, len01 = dist(p0, p1), len12 = dist(p1, p2);
    // The two long sides are the faces; normals point away from the wall's centre line.
    const sides = len01 >= len12 ? [[p0, p1], [p2, p3]] : [[p1, p2], [p3, p0]];
    const cx = (p0[0] + p2[0]) / 2, cy = (p0[1] + p2[1]) / 2;
    for (const [a, b] of sides) {
      const dx = b[0] - a[0], dy = b[1] - a[1], l = Math.hypot(dx, dy);
      if (l < 1) continue;
      let n = [-dy / l, dx / l];
      if ((a[0] - cx) * n[0] + (a[1] - cy) * n[1] < 0) n = [-n[0], -n[1]];
      out.push({ a, b, n, wall: w });
    }
  }
  return out;
}

/** Back of the item against the nearest wall face: rotation so the front (−Y) points along the face normal. */
export function snapToWall(p, item, faces) {
  let best = null;
  for (const f of faces) {
    const dx = f.b[0] - f.a[0], dy = f.b[1] - f.a[1], l2 = dx * dx + dy * dy;
    const t = Math.max(0, Math.min(1, ((p[0] - f.a[0]) * dx + (p[1] - f.a[1]) * dy) / l2));
    const q = [f.a[0] + t * dx, f.a[1] + t * dy], d = dist(p, q);
    if ((p[0] - q[0]) * f.n[0] + (p[1] - q[1]) * f.n[1] < -1) continue;   // behind this face (inside the wall or beyond)
    if (!best || d < best.d) best = { d, q, f };
  }
  if (!best) return null;
  const n = best.f.n;
  const rot = Math.atan2(-n[1], -n[0]) / D2R - 90;
  const b = planBounds(item.plan) || (item.body && item.body.type === 'box' ? { maxY: item.body.y + item.body.d } : { maxY: 0 });
  const maxY = b.maxY || 0;
  return { x: best.q[0] + n[0] * maxY, y: best.q[1] + n[1] * maxY, rot: Math.round(norm(rot) * 1000) / 1000, face: best.f, distance: best.d };
}

/**
 * The plan frame Copy gives an elements clip (bimcraft.js copyElements), so the ghost, wall snap and paste turn with the
 * element and not with the model's axes — a building turned in its site (true north, shared coordinates: Revit exports)
 * has every door and wall at an angle to them. rot = the first top-level element's own X axis in plan (degrees, model
 * axes), else the storey's, else 0; box = its meshes (openings and spaces left out) measured in those axes, round the
 * centre (x, y) in model mm, z from zBase (the storey's elevation). → { rot, x, y, box: { x0, y0, z0, x1, y1, z1 } } | null
 * (no geometry, or more than `maxPoints` vertices: the page then measures the viewer's box, turned 0°).
 */
elementsFrame(snap, { zBase = 0, maxPoints = 2e6 } = {}) {
  const api = this.api, mid = this.mid;
  const turn = (w) => (w && Math.hypot(w[0], w[1]) > 1e-6 ? Math.atan2(w[1], w[0]) / D2R : null);
  const top = snap.elements.find((e) => e.top);
  let rot = turn(top?.world);
  if (rot === null && snap.storey) { const st = api.GetLine(mid, snap.storey, false); rot = st?.ObjectPlacement ? turn(api.GetWorldTransformMatrix(mid, st.ObjectPlacement.value)) : null; }
  rot = Math.round(norm(rot ?? 0) * 1e6) / 1e6;
  const Ci = inv4(api.GetCoordinationMatrix(mid)), pts = [];
  for (const e of snap.elements) {
    if (/^Ifc(OpeningElement|OpeningStandardCase|Space)$/i.test(e.line?.constructor?.name || '')) continue;
    let tri;
    try { tri = productTriangles(api, mid, e.id, this.unitMm, Ci); } catch (err) { continue; }
    if (pts.length + tri.positions.length > maxPoints * 3) return null;
    for (let i = 0; i < tri.positions.length; i++) pts.push(tri.positions[i] * this.unitMm);
  }
  const b = orientedBox(pts, rot);
  return b ? { rot, x: b.x, y: b.y, box: { ...b.box, z0: b.box.z0 - zBase, z1: b.box.z1 - zBase } } : null;
}