@euphrasiologist/lwphylo 1.1.7 → 1.1.9

package/src/radial/radialLayout.js

@@ -3,17 +3,16 @@ import getRadii from "./getRadii.js"
 import getArcs from "./getArcs.js"
 
 /**
- * Simple wrapper function for getting the data,
- * radii, and arcs.
+ * Simple wrapper for radial layout:
+ *  - data: per-node { angle, r, x, y, ... }
+ *  - radii: per-edge radial spokes (parent.r → child.r)
+ *  - arcs: per-internal-node arcs spanning its children at parent radius
  */
-
-export default function (node) {
-  var data = {};
-
-  // TODO: does radial_data need to be printed out?
+export default function radialLayout(node) {
+  const data = {};
   data.data = radialData(node);
   data.radii = getRadii(node);
   data.arcs = getArcs(data.data);
-
   return data;
-}
+}
+

package/src/radial/reflectAngle.js

@@ -1,20 +1,10 @@
 /**
- * Takes parent data and returns a start value (radians),
- * end value (radians), and radius of circle to draw an 
- * arc from. 
- * thanks https://codereview.stackexchange.com/questions/187510/angle-reflection-function
+ * Legacy shim: normalize angle to [0, 2π).
+ * The new radial code does not need geometric reflections;
+ * it uses circular spans and atan2.
  */
+export default function reflectAngle(rad /*, dir */) {
+  const TAU = Math.PI * 2;
+  return ((rad % TAU) + TAU) % TAU;
+}
 
-export default function (rad, dir) {
-  const c = Math.cos(rad), s = Math.sin(rad);
-  const PI_sub = "3.1415";
-
-  function checkSign(x) {
-    if (x.toString().includes(PI_sub)) {
-      x = Math.abs(x);
-    }
-    return x;
-  }
-
-  return checkSign(Math.atan2(...(dir === "X" ? [s, -c] : [-s, c])));
-}

package/src/rectangle/getChildVerticals.js

@@ -0,0 +1,47 @@
+import getHorizontal from "./getHorizontal.js";
+
+/**
+ * Build per-child vertical segments for a rectangular tree:
+ * For each non-root node (child), draw a vertical from (parent.x, child.y) to (parent.x, parent.y).
+ * This yields exactly one vertical per edge (child->parent), making highlighting trivial.
+ *
+ * Returns an array of:
+ *   {
+ *     parentId: number,
+ *     childId: number,
+ *     x: number,         // x of the parent junction
+ *     y0: number,        // min(child.y, parent.y)
+ *     y1: number,        // max(child.y, parent.y)
+ *   }
+ */
+export default function getChildVerticals(node) {
+  const data = getHorizontal(node); // has parentId, thisId, x0,x1,y0=y1
+
+  // Build a quick index to access parent's y by id
+  const byId = new Map(data.map(d => [d.thisId, d]));
+
+  const childVerticals = [];
+
+  for (const d of data) {
+    if (d.parentId == null) continue;
+    const parent = byId.get(d.parentId);
+    if (!parent) continue;
+
+    const x = d.x0;            // child’s vertical sits at parent.x == child.x0
+    const yc = d.y0;           // child y
+    const yp = parent.y0;      // parent y
+    const y0 = Math.min(yc, yp);
+    const y1 = Math.max(yc, yp);
+
+    childVerticals.push({
+      parentId: d.parentId,
+      childId: d.thisId,
+      x,
+      y0,
+      y1
+    });
+  }
+
+  return childVerticals;
+}
+

package/src/rectangle/getHorizontal.js

@@ -2,11 +2,13 @@ import mean from "../utils/mean.js"
 import fortify from "../utils/fortify.js"
 
 /**
- * Rectangle layout algorithm.
- * Attempted copy of .layout.rect() function here https://github.com/ArtPoon/ggfree/blob/master/R/tree.R
+ * Rectangle layout: compute per-node x0,x1 and y0=y1
+ * - Tip y is assigned by input order (preserves ladderize/order)
+ * - Internal node y is mean of child y's
+ * - x1 accumulates branch lengths from root
  */
 
-export default function(node) {
+export default function getHorizontal(node) {
   const pd = fortify(node);
 
   // Fast lookup from id -> pd index
@@ -22,7 +24,7 @@ export default function(node) {
   // Map each leaf id to a vertical slot (1..N)
   const tipSlot = new Map(leafIds.map((id, i) => [id, i + 1]));
 
-  // 2) Set Y for tips directly from that order; compute Y for internal nodes via postorder
+  // 2) Set Y for tips directly from that order; internal node Y via children mean
   (function setY(n) {
     const i = idIndex.get(n.id);
     if (!n.children || n.children.length === 0) {
@@ -36,7 +38,7 @@ export default function(node) {
     return y;
   })(node);
 
-  // 3) Set X by accumulating branch lengths down the tree (no sorting-by-id needed)
+  // 3) Set X by accumulating branch lengths down the tree
   (function setX(n, xParent) {
     const i = idIndex.get(n.id);
     const bl = pd[i].branchLength ?? 0;
@@ -46,6 +48,10 @@ export default function(node) {
     if (n.children && n.children.length) n.children.forEach(c => setX(c, x1));
   })(node, 0);
 
-  // Clean up and return
-  return pd.map(({ y, x, angle, ...item }) => item);
+  // Clean up: remove fields not needed downstream without triggering no-unused-vars
+  return pd.map((row) => {
+    const { y: _y, x: _x, angle: _angle, ...item } = row;
+    return item;
+  });
 }
+

package/src/rectangle/getVertical.js

@@ -1,6 +1,6 @@
 import getHorizontal from "./getHorizontal.js"
 
-export default function (node) {
+export default function getVertical(node) {
   const data = getHorizontal(node);
 
   // Group rows by parentId (children that share a parent)
@@ -33,3 +33,4 @@ export default function (node) {
 
   return verticals;
 }
+

package/src/rectangle/rectangleLayout.js

@@ -1,15 +1,28 @@
-import getHorizontal from "./getHorizontal.js"
-import getVertical from "./getVertical.js"
+import getHorizontal from "./getHorizontal.js";
+import getVertical from "./getVertical.js";
+import getChildVerticals from "./getChildVerticals.js";
 
 /**
- * Simple wrapper for rectangle layout functions
+ * Rectangle layout wrapper.
+ * Returns:
+ *  - data: per-node rows (x0,x1,y0=y1,...)
+ *  - vertical_lines: single spanning vertical per parent (fast baseline draw)
+ *  - child_vertical_lines: one vertical per edge (child->parent) for highlighting
+ *  - horizontal_lines: child horizontals from parent.x -> child.x at child.y
  */
+export default function rectangleLayout(node) {
+  const data = getHorizontal(node); // per-node horizontally resolved
+  const vertical_lines = getVertical(node); // single spanning vertical per parent
+  const child_vertical_lines = getChildVerticals(node); // one vertical per child edge
 
-export default function (node) {
-  var data = {};
+  const horizontal_lines = data
+    .filter(d => d.parentId != null)
+    .map(d => ({
+      parentId: d.parentId,
+      childId: d.thisId,
+      x0: d.x0, x1: d.x1,
+      y: d.y0
+    }));
 
-  data.data = getHorizontal(node); // horizontal_lines
-  data.vertical_lines = getVertical(node);
-
-  return data;
-}
+  return { data, vertical_lines, child_vertical_lines, horizontal_lines };
+}

package/src/unrooted/equalAngleLayout.js

@@ -1,49 +1,60 @@
 import numTips from "../utils/numTips.js"
 
 /**
- * Equal-angle layout algorithm for unrooted trees.
- * Populates the nodes of a tree object with information on
- * the angles to draw branches such that they do not
- * intersect.
+ * Equal-angle layout for unrooted trees.
+ * - Precomputes ntips in O(n) to avoid repeated subtree counts
+ * - Uses angles in "π units" (0..2) to match existing API
+ * - Populates x,y positions from branchLength and angle
  */
 
+function annotateTipCounts(root) {
+  (function post(n) {
+    if (!n.children || n.children.length === 0) {
+      n.ntips = 1; return 1;
+    }
+    let sum = 0;
+    for (const c of n.children) sum += post(c);
+    n.ntips = sum;
+    return sum;
+  })(root);
+  return root;
+}
+
 function equalAngleLayout(node) {
   if (node.parent === null) {
-    // node is root
-    node.start = 0.;  // guarantees no arcs overlap 0
-    node.end = 2.; // *pi
-    node.angle = 0.;  // irrelevant
-    node.ntips = numTips(node);
+    annotateTipCounts(node);
+    node.start = 0.;     // guarantees no arcs overlap 0
+    node.end = 2.;       // *π
+    node.angle = 0.;     // irrelevant at root
+    node.ntips = numTips(node); // safe (already computed), left for compatibility
     node.x = 0;
     node.y = 0;
   }
 
-  var child, arc, lastStart = node.start;
+  let lastStart = node.start;
 
-  for (var i = 0; i < node.children.length; i++) {
-    // the child of the current node
-    child = node.children[i];
-    // the number of tips the child node has
-    child.ntips = numTips(child);
+  for (let i = 0; i < node.children.length; i++) {
+    const child = node.children[i];
+    const arc = (node.end - node.start) * (child.ntips / node.ntips);
 
-    // assign proportion of arc to this child
-    arc = (node.end - node.start) * child.ntips / node.ntips;
     child.start = lastStart;
-    child.end = child.start + arc;
+    child.end = lastStart + arc;
 
-    // bisect the arc
+    // bisect the arc in π-units
     child.angle = child.start + (child.end - child.start) / 2.;
     lastStart = child.end;
 
-    // map to coordinates
-    child.x = node.x + child.branchLength * Math.sin(child.angle * Math.PI);
-    child.y = node.y + child.branchLength * Math.cos(child.angle * Math.PI);
+    // map to coordinates (convert π-units to radians by multiplying by Math.PI)
+    const theta = child.angle * Math.PI;
+    const bl = (child.branchLength ?? 0);
+    child.x = node.x + bl * Math.sin(theta);
+    child.y = node.y + bl * Math.cos(theta);
 
-    // climb up
     equalAngleLayout(child);
   }
-  // had to add this!
+
   return node;
 }
 
-export default equalAngleLayout
+export default equalAngleLayout
+

package/src/unrooted/unrooted.js

@@ -15,4 +15,4 @@ export default function (node) {
   data.edges = edges(eq);
 
   return data;
-}
+}

package/src/utils/edges.js

@@ -4,52 +4,23 @@
  * are the $edge slot. I think.
  */
 
-export default function (df, rectangular = false) {
-  var result = [],
-    parent
+export default function edges(df, rectangular = false) {
+  const rows = [...df].sort((a, b) => a.thisId - b.thisId);
+  const byId = new Map(rows.map((r) => [r.thisId, r]));
+  const result = [];
 
-  // make sure data frame is sorted
-  df.sort(function (a, b) {
-    return a.thisId - b.thisId;
-  });
-
-  for (const row of df) {
-    if (row.parentId === null) {
-      continue; // skip the root
-    }
-    parent = df[row.parentId];
-    if (parent === null || parent === undefined) continue;
+  for (const row of rows) {
+    if (row.parentId == null) continue;
+    const parent = byId.get(row.parentId);
+    if (!parent) continue;
 
     if (rectangular) {
-      var pair1 = {
-        x1: row.x,
-        y1: row.y,
-        id1: row.thisId,
-        x2: parent.x,
-        y2: row.y,
-        id2: undefined
-      };
-      result.push(pair1);
-      var pair2 = {
-        x1: parent.x,
-        y1: row.y,
-        id1: undefined,
-        x2: parent.x,
-        y2: parent.y,
-        id2: row.parentId
-      };
-      result.push(pair2);
+      result.push({ x1: row.x, y1: row.y, id1: row.thisId, x2: parent.x, y2: row.y, id2: undefined });
+      result.push({ x1: parent.x, y1: row.y, id1: undefined, x2: parent.x, y2: parent.y, id2: row.parentId });
     } else {
-      var pair3 = {
-        x1: row.x,
-        y1: row.y,
-        id1: row.thisId,
-        x2: parent.x,
-        y2: parent.y,
-        id2: row.parentId
-      };
-      result.push(pair3);
+      result.push({ x1: row.x, y1: row.y, id1: row.thisId, x2: parent.x, y2: parent.y, id2: row.parentId });
     }
   }
   return result;
-}
+}
+

package/src/utils/indexing.js

@@ -0,0 +1,64 @@
+/**
+ * Build quick indexes for a fortified data frame.
+ */
+export function indexTree(df) {
+  const byId = new Map(df.map(r => [r.thisId, r]));
+  const children = new Map(df.map(r => [r.thisId, []]));
+  let root = null;
+  for (const r of df) {
+    if (r.parentId == null) { root = r.thisId; continue; }
+    children.get(r.parentId).push(r.thisId);
+  }
+  // depths (BFS)
+  const depth = new Map(); if (root != null) depth.set(root, 0);
+  const q = root != null ? [root] : [];
+  while (q.length) {
+    const u = q.shift();
+    for (const v of (children.get(u) || [])) {
+      depth.set(v, (depth.get(u) || 0) + 1);
+      q.push(v);
+    }
+  }
+  return { byId, children, depth, root };
+}
+
+/**
+ * Compute the node->root path for highlighting (returns [tip,...,root]).
+ */
+export function pathToRoot(dfIndex, nodeId) {
+  const { byId } = dfIndex;
+  const path = [];
+  let cur = nodeId;
+  while (cur != null) {
+    path.push(cur);
+    const row = byId.get(cur);
+    cur = row?.parentId ?? null;
+  }
+  return path;
+}
+
+/**
+ * Convert a path (node ids) to parent-child edge pairs.
+ */
+export function edgesOnPath(pathIds) {
+  const pairs = [];
+  for (let i = 0; i < pathIds.length - 1; i++) {
+    const child = pathIds[i], parent = pathIds[i + 1];
+    pairs.push({ child, parent });
+  }
+  return pairs;
+}
+
+/**
+ * Optional: split segments at midpoints (useful for finer-grain highlighting).
+ */
+export function splitEdges(segments) {
+  const out = [];
+  for (const s of segments) {
+    const mx = (s.x1 + s.x2) / 2, my = (s.y1 + s.y2) / 2;
+    out.push({ ...s, x2: mx, y2: my, half: "proximal" });
+    out.push({ ...s, x1: mx, y1: my, half: "distal" });
+  }
+  return out;
+}
+

package/src/utils/meanAngle.js

@@ -6,40 +6,15 @@
 * e.g. if the start/end angles are equal to pi, the sign must be flipped.
 */
 
+export default function meanAngle(a, b) {
+  // normalize to [0, 2pi)
+  const norm = (θ) => (θ % (2*Math.PI) + 2*Math.PI) % (2*Math.PI);
+  a = norm(a); b = norm(b);
 
-export default function (start, end) {
-  // if the angles are exactly equal but opposite
-  // return Math.PI (else undefined is returned...)
-  if (
-    Math.sign(start) !== Math.sign(end) &&
-    Math.abs(start) === Math.abs(end)
-  ) {
-    return Math.PI;
-  }
+  // handle wraparound by averaging unit vectors
+  const X = (Math.cos(a) + Math.cos(b)) / 2;
+  const Y = (Math.sin(a) + Math.sin(b)) / 2;
+  if (X === 0 && Y === 0) return 0; // opposite directions, arbitrary
+  return norm(Math.atan2(Y, X));
+}
 
-  // calculate the average sin and cosine for the angles
-  const X = (Math.cos(start) + Math.cos(end)) / 2,
-    Y = (Math.sin(start) + Math.sin(end)) / 2;
-
-  const signX = Math.sign(X),
-    signY = Math.sign(Y);
-
-  var meanAngle;
-  // adjustments for the sign of each of X, Y
-  if (signX === 1 && signY === 1) {
-    meanAngle = Math.atan(Y / X);
-  } else if (signX === 1 && signY === -1) {
-    meanAngle = 2 * Math.PI - Math.atan(Y / X);
-  } else if (signX === -1 && signY === 1) {
-    meanAngle = Math.PI - Math.atan(Y / X);
-  } else if (signX === -1 && signY === -1) {
-    meanAngle = Math.PI + Math.atan(Y / X);
-  }
-
-  // if the start or end angles are equal to PI (or close approximations)
-  // flip the sign.
-  return start.toString().indexOf("3.14159") > -1 ||
-    end.toString().indexOf("3.14159") > -1
-    ? -meanAngle
-    : meanAngle;
-}

package/src/utils/numTips.js

@@ -4,29 +4,24 @@
  */
 
 function levelorder(root) {
-    // aka breadth-first search
-    var queue = [root],
-        result = [],
-        curnode;
-
-    while (queue.length > 0) {
-        curnode = queue.pop();
-        result.push(curnode);
-        for (const child of curnode.children) {
-            queue.push(child);
-        }
-    }
-    return (result);
+  const queue = [root], result = [];
+  while (queue.length) {
+    const curnode = queue.shift();         // <- FIFO
+    result.push(curnode);
+    for (const child of curnode.children) queue.push(child);
+  }
+  return result;
 }
 
+
 /**
  * Count the number of tips that descend from this node
  */
 
-export default function (thisnode) {
-    var result = 0;
-    for (const node of levelorder(thisnode)) {
-        if (node.children.length == 0) result++;
-    }
-    return (result);
-}
+export default function(thisnode) {
+  var result = 0;
+  for (const node of levelorder(thisnode)) {
+    if (node.children.length == 0) result++;
+  }
+  return (result);
+}

package/src/utils/parentFisheye.js

@@ -1,11 +1,9 @@
-// find the x & y coordinates of the parental species
-export default function (d, data /* e.g. lwPhylo.unrooted.data */) {
-  for (let i = 0; i < data.length; i++) {
-    if (d.parentId === data[i].thisId) {
-      return {
-        px: data[i].fisheye.x,
-        py: data[i].fisheye.y
-      };
-    }
-  }
-}
+export function makeIndexById(rows, key = "thisId") {
+  return new Map(rows.map(d => [d[key], d]));
+}
+export default function parentFisheye(d, data) {
+  const byId = makeIndexById(data);
+  const parent = byId.get(d.parentId);
+  return parent ? { px: parent.fisheye.x, py: parent.fisheye.y } : null;
+}
+

package/src/utils/preorder.js

@@ -1,11 +1,38 @@
 /**
- * Recursive function for pre-order traversal of tree
+ * Recursive function for pre-order traversal of tree (returns array)
  */
-
 export function preorder(node, list = []) {
-    list.push(node);
-    for (var i = 0; i < node.children.length; i++) {
-        list = preorder(node.children[i], list);
+  list.push(node);
+  for (let i = 0; i < (node.children?.length || 0); i++) {
+    list = preorder(node.children[i], list);
+  }
+  return list;
+}
+
+/**
+ * Iterative generator traversals (avoid recursion limits on large trees)
+ */
+export function* preorderIter(root) {
+  const stack = [root];
+  while (stack.length) {
+    const n = stack.pop();
+    yield n;
+    if (n.children) for (let i = n.children.length - 1; i >= 0; --i) stack.push(n.children[i]);
+  }
+}
+
+export function* postorderIter(root) {
+  const stack = [[root, 0]];
+  while (stack.length) {
+    const top = stack[stack.length - 1];
+    const [n, i] = top;
+    if (!n.children || i >= n.children.length) {
+      stack.pop();
+      yield n;
+    } else {
+      top[1] = i + 1;
+      stack.push([n.children[i], 0]);
     }
-    return (list);
+  }
 }
+