Arcs from bulges and three points

/** The arc's centre, radius, start angle and sweep (null for a straight segment). */
export function arcOf(p, q, b) {
  if (!b) return null;
  const c = dist(p, q);
  if (!c) return null;
  const th = 4 * Math.atan(b);
  const mx = (p.x + q.x) / 2, my = (p.y + q.y) / 2;
  const k = (c / 2) / Math.tan(th / 2);                 // centre's distance left of p → q
  const cx = mx - (q.y - p.y) / c * k, cy = my + (q.x - p.x) / c * k;
  const r = Math.hypot(p.x - cx, p.y - cy);
  return { cx, cy, r, a0: Math.atan2(p.y - cy, p.x - cx), sweep: th };
}

/** Bulge of the arc that starts at p, passes through m and ends at q (0 if they are in a line). */
export function bulgeThrough(p, m, q) {
  const o = (m.x - p.x) * (q.y - p.y) - (m.y - p.y) * (q.x - p.x);
  const span = Math.max(dist(p, m), dist(m, q), dist(p, q));
  if (!span || Math.abs(o) <= 1e-9 * span * span) return 0;
  // circumcentre
  const ax = p.x, ay = p.y, bx = m.x, by = m.y, cx = q.x, cy = q.y;
  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
  const ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d;
  const uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d;
  const a0 = Math.atan2(ay - uy, ax - ux), a2 = Math.atan2(cy - uy, cx - ux);
  let sweep = a2 - a0;
  // o = (m − p) × (q − p) > 0: the triangle p, m, q is counter-clockwise, and so is the arc p → m → q
  if (o > 0) { while (sweep <= 0) sweep += 2 * Math.PI; } else { while (sweep >= 0) sweep -= 2 * Math.PI; }
  return Math.tan(sweep / 4);
}

export function segmentLengths(pts) {
  const out = [];
  for (let i = 1; i < pts.length; i++) out.push(segLength(pts[i - 1], pts[i], pts[i - 1].b));
  return out;
}
export const polylineLength = (pts) => segmentLengths(pts).reduce((s, v) => s + v, 0);

/** Snap p to the nearest 45° direction from base, keeping its distance along that direction. */
export function snap45(base, p) {
  const dx = p.x - base.x, dy = p.y - base.y;
  const ang = Math.round(Math.atan2(dy, dx) / (Math.PI / 4)) * (Math.PI / 4);
  const ux = Math.round(Math.cos(ang) * 1e12) / 1e12, uy = Math.round(Math.sin(ang) * 1e12) / 1e12;
  const t = dx * ux + dy * uy;
  return { x: base.x + ux * t, y: base.y + uy * t };
}

/** A circle as two half-circle arcs (exact area and perimeter): a new area, or a round cut-out. */
function finishCircle(c, edge) {
  app.draft = null;
  closeTypeIn();
  ui.measure.textContent = '';
  const r = G.dist(c, edge);
  if (r * view.z < 3) { status(t('circle.err.small')); view.overlayOnly(); return; }
  const pts = [{ x: c.x + r, y: c.y, b: 1 }, { x: c.x - r, y: c.y, b: 1 }];
  if (app.tool === 'cutcircle') {
    const m = model.mark(app.sel);
    if (!m) return;
    const why = G.holeProblem(m.pts, m.holes, pts);
    if (why) { status(why, 9000); view.overlayOnly(); return; }
    model.updateMark(m.id, { holes: [...m.holes, pts] }, t('undo.cutout.round'));
    status(t('cutout.round.added'));
    return;
  }
  app.sel = model.addMark({ item: app.active, sheet: cur.key, pts, kind: 'area', ...inArea() });
  renderMarkProps();
}

const b = G.bulgeThrough(a, p, z);
ring[g.i] = Math.abs(b) > 1e-6 && Math.abs(b) < 1e3 ? { x: a.x, y: a.y, b } : { x: a.x, y: a.y };

function liveMeasure() {
  const d = app.draft;
  if (!d || !cur || !app.cursor) return;
  const sc = model.scaleOf(cur.key);
  const pts = previewPts();
  if (app.tool === 'calibrate') { ui.measure.textContent = d.pts.length ? t('cal.second') : ''; return; }
  if (!sc) { ui.measure.textContent = ''; return; }
  const k = sc.ftPerUnit;
  const lastSeg = pts.length >= 2 ? G.segLength(pts.at(-2), pts.at(-1), pts.at(-2).b) * k : 0;
  const arcNote = d.mid ? '   ' + t('measure.arc') : '';
  if (app.tool === 'circle' || app.tool === 'cutcircle') {
    const r = G.dist(d.pts[0], app.cursor) * k;
    ui.measure.textContent = t('measure.circle', { r: ftIn(r), area: U.fixed(Math.PI * r * r, 2) });
  } else if (app.tool === 'linear' || app.tool === 'check') {
    if (app.tool === 'linear') {
      // deduct segments (T2) are left out of the run's length; the one under way follows the Deduct button
      const segs = G.segmentLengths(pts);
      const net = segs.reduce((n, len, i) => n + ((i === segs.length - 1 ? app.deduct : d.ded?.has(i)) ? 0 : len), 0);
      ui.measure.textContent = t('measure.run', { len: ftIn(net * k), seg: app.deduct ? t('deduct.seg', { len: ftIn(lastSeg) }) : ftIn(lastSeg) }) + arcNote;
    } else ui.measure.textContent = ftIn(lastSeg) + arcNote;
  } else if (app.tool === 'area' || app.tool === 'cutout') {
    ui.measure.textContent = (pts.length >= 3 || G.hasArcs(pts) ? t('measure.area', { area: U.fixed(G.polygonArea(pts) * k * k, 2), p: ftIn(G.perimeter(pts) * k) }) : t('measure.side', { len: ftIn(lastSeg) })) + arcNote;
  }
}

const ft = G.dist(pts[0], pts[1]) * sc.ftPerUnit;
app.check = { a: pts[0], b: pts[1], text: ftIn(ft) };
ui.measure.textContent = t('check.result', { len: ftIn(ft), ft: U.fixed(ft, 3), m: U.fixed(ft * U.M_PER_FT, 3) });

/** Drop points that sit on the one before (a double-click adds two). */
function dedupe(pts) {
  const tol = 2 / view.z;
  const out = [];
  for (const p of pts) if (!out.length || G.dist(out.at(-1), p) > tol) out.push(p);
  return out;
}