Ellipses and curves as short segments

export function ellipsePoints(e, steps = ELLIPSE_STEPS) {
  const ma = Math.hypot(e.mx, e.my), mi = ma * e.ratio, rot = Math.atan2(e.my, e.mx);
  const [t0, t1] = e.t1 - e.t0 >= TAU - EPS ? [0, TAU] : arcRange(e.t0, e.t1);
  const n = Math.max(8, Math.ceil(steps * (t1 - t0) / TAU));
  const c = Math.cos(rot), s = Math.sin(rot), pts = [];
  for (let i = 0; i <= n; i++) {
    const t = t0 + (t1 - t0) * i / n, x = ma * Math.cos(t), y = mi * Math.sin(t);
    pts.push({ x: e.cx + x * c - y * s, y: e.cy + x * s + y * c });
  }
  return pts;
}

const a = Math.hypot(e.mx, e.my), b = a * e.ratio;
if (e.t1 - e.t0 >= TAU - EPS || Math.abs(normAngle(e.t1 - e.t0)) < EPS) {
  const h = ((a - b) / (a + b)) ** 2;
  return { area: Math.PI * a * b, perimeter: Math.PI * (a + b) * (1 + 3 * h / (10 + Math.sqrt(4 - 3 * h))), kind: 'closed' };
}
const pts = ellipsePoints(e, 720), m = polygonMeasure(pts);
let len = 0;
for (let i = 0; i + 1 < pts.length; i++) len += dist(pts[i], pts[i + 1]);
return { area: Math.abs(m.area), perimeter: len, kind: 'open' };

/** A primitive through a transform (arcs become polylines when the transform is not similar). */
export function txPrim(p, m) {
  if (p.k === 'L') { const a = mApply(m, { x: p.x1, y: p.y1 }), b = mApply(m, { x: p.x2, y: p.y2 }); return [{ k: 'L', x1: a.x, y1: a.y, x2: b.x, y2: b.y }]; }
  const sim = mSimilar(m);
  if (sim) {
    const c = mApply(m, { x: p.cx, y: p.cy });
    if (p.full) return [{ k: 'A', cx: c.x, cy: c.y, r: p.r * sim.s, a0: 0, a1: TAU, full: true }];
    // A mirror reverses the direction of travel: the image of the old end is the new CCW start.
    const s = mApply(m, primPoint(p, sim.flip ? 1 : 0));
    const a0 = normAngle(Math.atan2(s.y - c.y, s.x - c.x));
    return [{ k: 'A', cx: c.x, cy: c.y, r: p.r * sim.s, a0, a1: a0 + (p.a1 - p.a0) }];
  }
  const out = [], n = Math.max(8, Math.ceil(48 * (p.a1 - p.a0) / TAU));
  let prev = mApply(m, primPoint(p, 0));
  for (let i = 1; i <= n; i++) { const q = mApply(m, primPoint(p, i / n)); out.push({ k: 'L', x1: prev.x, y1: prev.y, x2: q.x, y2: q.y }); prev = q; }
  return out;
}

/** An object's outline as points (arcs and curves in short pieces): { pts, closed } | null. */
export function pathOf(e) {
  if (e.type === 'circle') { const n = 96, pts = []; for (let i = 0; i < n; i++) pts.push(polar({ x: e.cx, y: e.cy }, (i / n) * TAU, e.r)); return { pts, closed: true }; }
  if (e.type === 'ellipse') { const pts = ellipsePoints(e, 144); const closed = e.t1 - e.t0 >= TAU - 1e-9; if (closed) pts.pop(); return { pts, closed }; }
  if (e.type === 'spline' && splineValid(e)) { const pts = splinePolyline(e, 24); return { pts, closed: !!e.closed }; }
  if (e.type === 'line') return { pts: [{ x: e.x1, y: e.y1 }, { x: e.x2, y: e.y2 }], closed: false };
  if (e.type === 'arc') { const p = prims(e)[0], n = Math.max(8, Math.ceil((p.a1 - p.a0) / (TAU / 96))), pts = []; for (let i = 0; i <= n; i++) pts.push(primPoint(p, i / n)); return { pts, closed: false }; }
  if (e.type === 'poly' && e.pts.length >= 2) {
    const pts = [];
    for (const p of polyPrims(e)) {
      if (p.k === 'L') { pts.push({ x: p.x1, y: p.y1 }); continue; }
      const n = Math.max(4, Math.ceil((p.a1 - p.a0) / (TAU / 96)));
      for (let i = 0; i < n; i++) pts.push(primPoint(p, p.rev ? 1 - i / n : i / n));
    }
    if (!e.closed) pts.push({ x: e.pts[e.pts.length - 1].x, y: e.pts[e.pts.length - 1].y });
    return { pts, closed: !!e.closed };
  }
  return null;
}

/** Points spaced evenly along a path (about `step` apart; corners need not be kept). */
export function resamplePath(pts, closed, step) {
  const ring = closed ? [...pts, pts[0]] : pts;
  const lens = [];
  let L = 0;
  for (let i = 0; i + 1 < ring.length; i++) { const d = dist(ring[i], ring[i + 1]); lens.push(d); L += d; }
  if (!(L > EPS) || !(step > EPS)) return pts.slice();
  const n = Math.max(closed ? 3 : 1, Math.round(L / step));
  const out = [];
  let seg = 0, acc = 0;
  for (let k = 0; k <= n; k++) {
    if (closed && k === n) break;
    const target = (L * k) / n;
    while (seg < lens.length - 1 && acc + lens[seg] < target - 1e-12) { acc += lens[seg]; seg++; }
    const t = lens[seg] > 0 ? (target - acc) / lens[seg] : 0;
    out.push({ x: ring[seg].x + (ring[seg + 1].x - ring[seg].x) * t, y: ring[seg].y + (ring[seg + 1].y - ring[seg].y) * t });
  }
  return out;
}

/**
 * A revision cloud along a path: a polyline of arcs about `arcLen` long that bulge outward (inward with `reverse`).
 * → poly entity fields { type: 'poly', closed, pts }.
 */
export function revcloud(pts, closed, arcLen, reverse = false) {
  const q = resamplePath(pts, closed, arcLen);
  let a = 0;
  for (let i = 0; i < q.length; i++) { const u = q[i], v = q[(i + 1) % q.length]; a += u.x * v.y - v.x * u.y; }
  // travelling counter-clockwise the outside is on the right, where a positive bulge goes
  const sign = (closed ? (a >= 0 ? 1 : -1) : 1) * (reverse ? -1 : 1);
  return { type: 'poly', closed, pts: q.map((p, i) => ({ x: p.x, y: p.y, b: closed || i < q.length - 1 ? sign * CLOUD_BULGE : 0 })) };
}

if (e.type === 'spline') {   // a polyline along the curve (precision 10 per knot span)
  if (!splineValid(e)) return null;
  const pts = splinePolyline(e, 10);
  return pts.length >= 2 ? [{ type: 'poly', layer: e.layer, color: e.color ?? null, closed: !!e.closed, pts: pts.map((q) => ({ x: q.x, y: q.y, b: 0 })) }] : null;
}