@euphrasiologist/lwphylo 1.2.5 → 1.2.7

package/dist/index.cjs

@@ -174,6 +174,18 @@ function describeArc(cx, cy, radius, startAngle, endAngle) {
   return `M ${p0.x} ${p0.y} A ${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${p1.x} ${p1.y}`;
 }
 
+// describeArcSweep.js
+function describeArcSweep(cx, cy, r, a0, a1, sweep /*0=CCW,1=CW*/) {
+  const TAU = Math.PI * 2;
+  const norm = (t) => ((t % TAU) + TAU) % TAU;
+  const delta = sweep === 0 ? norm(a1 - a0) : norm(a0 - a1); // magnitude on chosen sweep
+  if (delta < 1e-9 || r <= 0) return "";
+  const largeArcFlag = delta > Math.PI ? 1 : 0;
+  const p0 = { x: cx + r * Math.cos(a0), y: cy - r * Math.sin(a0) };
+  const p1 = { x: cx + r * Math.cos(a1), y: cy - r * Math.sin(a1) };
+  return `M ${p0.x} ${p0.y} A ${r} ${r} 0 ${largeArcFlag} ${sweep} ${p1.x} ${p1.y}`;
+}
+
 /**
  * Recursive function for pre-order traversal of tree (returns array)
  */
@@ -447,6 +459,112 @@ function getChildArcs(pd) {
   return arcs;
 }
 
+// fanAngles.js
+const TAU = Math.PI * 2;
+const norm = (t) => ((t % TAU) + TAU) % TAU;
+
+// Unwrap angles around a reference so they sit within [ref-π, ref+π]
+function unwrapAround(ref, a) {
+  let x = a;
+  while (x < ref - Math.PI) x += TAU;
+  while (x > ref + Math.PI) x -= TAU;
+  return x;
+}
+
+/**
+ * Compute APE "fan" compatible angles:
+ *  - Tips evenly spaced over [0, span] where span = 2π*(1 - 1/Ntip) - gap
+ *  - Then + rotate (radians)
+ *  - Internal nodes = arithmetic mean of child angles (unwrapped)
+ *
+ * pd: fortified nodes array (has thisId, parentId, children[])
+ * opts: { openAngleDeg=0, rotateDeg=0 }
+ * returns: Map(nodeId -> angle)
+ */
+function fanAngles(pd, opts = {}) {
+  const { openAngleDeg = 0, rotateDeg = 0 } = opts;
+  const gap = (openAngleDeg / 360) * TAU;
+  const rotate = (rotateDeg / 360) * TAU;
+
+  // Find root and collect tips in cladewise/DFS order
+  let root = null;
+  const kids = new Map(pd.map(d => [d.thisId, d.children || []]));
+  for (const d of pd) if (d.parentId == null) { root = d.thisId; break; }
+
+  const tipIds = [];
+  (function dfs(id) {
+    const c = kids.get(id) || [];
+    if (!c.length) { tipIds.push(id); return; }
+    for (const ch of c) dfs(ch);
+  })(root);
+
+  const N = Math.max(1, tipIds.length);
+  // APE: 0 .. 2π*(1 - 1/N) - gap, length.out=N (no last step overlap)
+  const maxA = TAU * (1 - 1 / N) - gap;
+  const step = N > 1 ? maxA / (N - 1) : 0;
+
+  const angle = new Map();
+  tipIds.forEach((id, i) => {
+    angle.set(id, norm(i * step + rotate));
+  });
+
+  // Internal nodes: arithmetic mean of child angles (unwrapped)
+  (function setInternal(id) {
+    const c = kids.get(id) || [];
+    for (const ch of c) setInternal(ch);
+    if (c.length > 0) {
+      // unwrap child angles around the first child's angle
+      const a0 = angle.get(c[0]);
+      const unwrapped = c.map(ch => unwrapAround(a0, angle.get(ch)));
+      const mean = unwrapped.reduce((s, v) => s + v, 0) / unwrapped.length;
+      angle.set(id, norm(mean));
+    }
+  })(root);
+
+  return angle;
+}
+
+// getArcsFan.js
+
+/**
+ * Build arcs like APE's circular.plot:
+ *  For each internal parent, draw a single arc at radius=parent.r
+ *  going from first child's angle to last child's angle in child order.
+ *  If last < first (wrap), we draw CW (decreasing) to stay on the block.
+ *
+ * pd: array with { thisId, parentId, r, children[], angle }
+ * returns: [{ parentId, thisId, radius, start, end, sweep }] 
+ *   where sweep=0 means CCW (start→end increasing),
+ *         sweep=1 means CW  (start→end decreasing across wrap).
+ */
+function getArcsFan(pd) {
+  const byId = new Map(pd.map(d => [d.thisId, d]));
+  const arcs = [];
+
+  for (const p of pd) {
+    const c = p.children || [];
+    if (c.length < 2) continue;
+    const A = c.map(id => byId.get(id)?.angle).filter(a => a != null);
+    if (A.length < 2 || !isFinite(p.r) || p.r <= 0) continue;
+
+    // Children are contiguous in tip order; take first and last
+    let start = A[0];
+    let end = A[A.length - 1];
+
+    // Decide direction like APE’s seq(start, end): 
+    // if end >= start → CCW; else CW across wrap.
+    const sweep = end >= start ? 0 : 1;
+
+    arcs.push({
+      parentId: p.parentId,
+      thisId: p.thisId,
+      radius: p.r,
+      start, end, sweep
+    });
+  }
+  return arcs;
+}
+
 /**
  * Simple wrapper for radial layout:
  *  - data: per-node { angle, r, x, y, ... }
@@ -454,12 +572,29 @@ function getChildArcs(pd) {
  *  - arcs: per-parent arcs spanning all children at parent's radius
  *  - child_arcs: per-child half-arcs (parent.angle → child.angle) at parent's radius
  */
-function radialLayout(node) {
+function radialLayout(node, opts =  {}) {
   const data = {};
   data.data = radialData(node);
   data.radii = getRadii(node);
   data.arcs = getArcs(data.data);
   data.child_arcs = getChildArcs(data.data);
+
+  const pd = fortify(node, true);
+  const angleMap = fanAngles(pd, {
+    openAngleDeg: opts.openAngleDeg ?? 0,
+    rotateDeg: opts.rotateDeg ?? 0
+  });
+
+  // stamp angles + x,y back onto pd (r stays your cumulative edge length)
+  for (const d of pd) {
+    d.angle = angleMap.get(d.thisId) ?? 0;
+    d.x = d.r * Math.cos(d.angle);
+    d.y = d.r * Math.sin(d.angle);
+  }
+
+  data.data_pd = pd;
+  data.arcs_fan = getArcsFan(pd);
+
   return data;
 }
 
@@ -1641,6 +1776,7 @@ function drawPhylogeny(
 }
 
 exports.describeArc = describeArc;
+exports.describeArcSweep = describeArcSweep;
 exports.drawPhylogeny = drawPhylogeny;
 exports.parentFisheye = parentFisheye;
 exports.phisheye = phisheye;