Sketch profiles for exact solids

/**
 * Closed loops of a sketch's non-construction lines, arcs and circles, keeping each curve:
 * → { loops: [{ segs: [{ id, type, a, b, mid?, c?, r? }], poly }] } or { error }.
 */
export function profileCurves(sk) {
  const tol = 1e-6 * Math.max(1, extent(sk));
  const loops = [];
  const segs = [];
  for (const e of sk.entities) {
    if (e.construction) continue;
    if (e.type === 'circle') {
      if (!(e.r > tol)) return { error: tr('model.brep.circle_no_size') };
      const c = pointXY(sk, e.c);
      loops.push({ segs: [{ id: e.id, type: 'circle', c, r: e.r }], poly: tessCircle(c, e.r, 128) });
    } else if (e.type === 'line') {
      const a = pointXY(sk, e.p1), b = pointXY(sk, e.p2);
      if (Math.hypot(b[0] - a[0], b[1] - a[1]) <= tol) return { error: tr('model.brep.line_no_length') };
      segs.push({ id: e.id, type: 'line', a, b, pts: [a, b] });
    } else if (e.type === 'arc') {
      const { c, r, a0, sweep } = arcAngles(sk, e);
      if (!(r > tol)) return { error: tr('model.brep.arc_no_size') };
      const pts = tessArc(sk, e, 128);
      segs.push({ id: e.id, type: 'arc', a: pts[0], b: pts[pts.length - 1], c, r, mid: [c[0] + r * Math.cos(a0 + sweep / 2), c[1] + r * Math.sin(a0 + sweep / 2)], pts });
    } else if (e.type === 'spline') {
      // exact B-spline (sketch-spline.js); the polyline only decides nesting
      let bs;
      try { bs = splineCurve(sk, e); } catch (err) { return { error: err.message }; }
      const pts = SP.tessellate(bs, 16);
      if (e.closed) { pts.pop(); loops.push({ segs: [{ id: e.id, type: 'spline', bs, closed: true }], poly: pts }); }
      else segs.push({ id: e.id, type: 'spline', a: pts[0], b: pts[pts.length - 1], bs, pts });
    }
  }
  const nodes = [];
  const nodeOf = (p) => {
    for (let i = 0; i < nodes.length; i++) if (Math.hypot(nodes[i].p[0] - p[0], nodes[i].p[1] - p[1]) <= tol * 10) return i;
    nodes.push({ p, ends: [] });
    return nodes.length - 1;
  };
  for (const s of segs) {
    s.n0 = nodeOf(s.a); s.n1 = nodeOf(s.b);
    nodes[s.n0].ends.push(s); nodes[s.n1].ends.push(s);
  }
  const fx = (v) => String(+v.toFixed(3));
  for (const n of nodes) {
    if (n.ends.length === 1) return { error: tr('model.brep.profile_open', { x: fx(n.p[0]), y: fx(n.p[1]) }), at: n.p };
    if (n.ends.length > 2) return { error: tr('model.brep.profile_branches', { x: fx(n.p[0]), y: fx(n.p[1]) }), at: n.p };
  }
  const used = new Set();
  for (const s0 of segs) {
    if (used.has(s0)) continue;
    const out = [], poly = [];
    const start = s0.n0;
    let s = s0, from = start;
    for (let guard = 0; guard <= segs.length; guard++) {
      used.add(s);
      const fwd = s.n0 === from;
      const to = fwd ? s.n1 : s.n0;
      // both ends sit exactly on the shared node, so neighbouring edges meet at one vertex
      out.push({ id: s.id, type: s.type, a: nodes[from].p, b: nodes[to].p, mid: s.mid, c: s.c, r: s.r, bs: s.bs && (fwd ? s.bs : SP.reverse(s.bs)) });
      const pts = fwd ? s.pts : [...s.pts].reverse();
      for (let i = 0; i < pts.length - 1; i++) poly.push(pts[i]);
      if (to === start) break;
      const nx = nodes[to].ends.find((q) => q !== s);
      if (!nx || used.has(nx)) break;
      from = to; s = nx;
    }
    if (poly.length < 3) return { error: tr('model.brep.loop_too_few') };
    loops.push({ segs: out, poly });
  }
  return { loops };
}

const arc = T(T(new oc.GC_MakeArcOfCircle(H.pnt(W(s.a)), H.pnt(W(s.mid)), H.pnt(W(s.b)))).Value());
e = T(new oc.BRepBuilderAPI_MakeEdge(arc, vtx(s.a), vtx(s.b))).Edge();

function signedArea(poly) {
  let s = 0;
  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) s += poly[j][0] * poly[i][1] - poly[i][0] * poly[j][1];
  return s / 2;
}

/** A point just inside a loop polygon's first edge (for nesting tests that do not hit shared lines). */
function innerPoint(poly) {
  // the centroid of a triangle fan sample is fragile for concave loops; use a point a hair to the inner side of the longest edge
  let best = 0, bi = 0;
  for (let i = 0; i < poly.length; i++) { const a = poly[i], b = poly[(i + 1) % poly.length]; const l = Math.hypot(b[0] - a[0], b[1] - a[1]); if (l > best) { best = l; bi = i; } }
  const a = poly[bi], b = poly[(bi + 1) % poly.length];
  const m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
  const nx = -(b[1] - a[1]) / best, ny = (b[0] - a[0]) / best;
  const s = Math.sign(signedArea(poly)) || 1;   // left of the edge is inside for a CCW loop
  const eps = 1e-6 * Math.max(1, best);
  return [m[0] + nx * eps * s, m[1] + ny * eps * s];
}

const depth = loops.map((L, i) => loops.reduce((k, M, j) => k + (j !== i && insideLoops([M.poly], innerPoint(L.poly)) ? 1 : 0), 0));
const pln = T(new oc.gp_Pln(T(new oc.gp_Ax3(H.pnt(V.add(fr.o, V.mul(fr.n, lift))), H.dir(fr.n), H.dir(fr.x)))));
const faces = [];
for (let i = 0; i < n; i++) {
  // regions (picked contours, brep-design.js regionsAt): each { outer, holes } overrides the even-odd rule
  const reg = regions ? regions.find((g) => g.outer === i) : null;
  if (regions ? !reg : depth[i] % 2) continue;

/** A reference to an edge of a regen, for a fillet or chamfer. */
export const edgeRef = (e) => ({ faces: [...e.faces], at: e.at.map((v) => +v.toFixed(6)) });