@euphrasiologist/lwphylo 1.1.5 → 1.1.9

package/src/radial/radialData.js

@@ -1,102 +1,84 @@
 import fortify from "../utils/fortify.js"
-import numTips from "../utils/numTips.js"
-import mean from "../utils/mean.js"
 
 /**
- * Take a parsed tree and get the important data from them (i.e. radii, arcs).
+ * Compute per-node polar coordinates for radial layout:
+ *  - Tip angles: evenly spaced 0..2π in tip DFS order
+ *  - Internal angles: circular mean of child angles
+ *  - Radii: cumulative branch length from root
+ *  - x,y: cartesian projection
+ *
+ * Returns the fortified array with added {angle, r, x, y}.
  */
-
-export default function (node) {
-  // should start out the same as get_horizontal
-  // it's very similar in fact, but keeping separate for clarity.
-  var pd = fortify(node);
-
-  var tip_number = numTips(node);
-
-  // make tip angles
-  var tipID = 1;
-  for (let i = 0; i < pd.length; i++) {
-    if (pd[i].isTip == true) {
-      pd[i].angle = (tipID / tip_number) * 2 * Math.PI;
-      tipID += 1;
-    }
+export default function radialData(node) {
+  const TAU = Math.PI * 2;
+  const norm = (t) => ((t % TAU) + TAU) % TAU;
+
+  const pd = fortify(node, /*sort*/ true);
+  const byId = new Map(pd.map(d => [d.thisId, d]));
+  const kids = new Map(pd.map(d => [d.thisId, d.children || []]));
+
+  // Find root id
+  let root = null;
+  for (const d of pd) {
+    if (d.parentId == null) { root = d.thisId; break; }
   }
 
-  // probably incredibly inefficient for large trees.
-  // gets the y values of two child branches by looping through the whole tree...
-  function internalNodeAngle(child_1, child_2) {
-    for (var i = 0; i < pd.length; i++) {
-      if (pd[i].thisId === child_1) {
-        var angle_1 = pd[i].angle;
-      }
-      if (pd[i].thisId === child_2) {
-        var angle_2 = pd[i].angle;
-      }
+  // Collect tip ids in DFS left->right order to preserve input ordering
+  const tipIds = [];
+  (function dfs(id) {
+    const c = kids.get(id) || [];
+    if (c.length === 0) {
+      tipIds.push(id);
+      return;
     }
-    return mean([angle_1, angle_2]); // see utils.js
-  }
-
-  // if the node is not a tip...
-  for (let i = 0; i < pd.length; i++) {
-    if (pd[i].isTip === false) {
-      // then y0 === y1 and is the mean of the parental nodes
-      pd[i].angle = internalNodeAngle(pd[i].children[0], pd[i].children[1]);
-    }
-  }
-
-  // find root
-  var root = pd.map(d => d.parentId === null ? d.thisId : null).filter(d => d != null)[0];
-
-  // sort the data temporarily in decreasing parentId
-  pd.sort((a, b) => b.thisId - a.thisId);
-
-  // get the branchlength of the parentID
-  function getParentBranchLength(current_parentId) {
-    for (var i = 0; i < pd.length; i++) {
-      if (pd[i].thisId === current_parentId) {
-        var branchLength = pd[i].r;
+    for (const ch of c) dfs(ch);
+  })(root);
+
+  // Assign tip angles evenly spaced 0..2π
+  const N = Math.max(1, tipIds.length);
+  const angle = new Map();
+  tipIds.forEach((id, i) => {
+    angle.set(id, (i / N) * TAU);
+  });
+
+  // Internal node angles: circular mean of child angles (post-order)
+  (function setInternalAngles(id) {
+    const c = kids.get(id) || [];
+    for (const ch of c) setInternalAngles(ch);
+    if (c.length > 0) {
+      let sx = 0, sy = 0;
+      for (const ch of c) {
+        const th = angle.get(ch);
+        sx += Math.cos(th);
+        sy += Math.sin(th);
       }
+      angle.set(id, norm(Math.atan2(sy, sx)));
     }
-    return branchLength;
-  }
-
-  // assign depths (branch lengths) to radii
-  for (let i = 0; i < pd.length; i++) {
-    // special cases where parent is the root.
-    if (pd[i].parentId === root) {
-
-      if (pd[i].isTip === true) {
-        // radius is branch length at root?
-        pd[i].r = pd[i].branchLength;
-        pd[i].x = pd[i].branchLength;
-        pd[i].y = 0;
-
-      } else { // it's a node
-        // radius is branch length at root?
-        pd[i].r = pd[i].branchLength;
-        pd[i].x = pd[i].branchLength * Math.cos(pd[i].angle);
-        pd[i].y = pd[i].branchLength * Math.sin(pd[i].angle);
-      }
-
-    } else {
-      // the x0 is that of the parent
-      var parent_branchLength = getParentBranchLength(pd[i].parentId);
-      // the x1 is the sum of parent and current branchlength
-      pd[i].r = parent_branchLength + pd[i].branchLength;
-      // at the same time we can make x and y from polar coordinates
-      // this is creating some NaN's, may cause problems later.
-      pd[i].x = (parent_branchLength + pd[i].branchLength) * Math.cos(pd[i].angle);
-      pd[i].y = (parent_branchLength + pd[i].branchLength) * Math.sin(pd[i].angle);
+  })(root);
+
+  // Radii: cumulative branch lengths from root (root r=0)
+  const radius = new Map();
+  radius.set(root, 0);
+  (function setR(id) {
+    const c = kids.get(id) || [];
+    const r0 = radius.get(id) || 0;
+    for (const ch of c) {
+      const child = byId.get(ch);
+      const bl = child?.branchLength ?? 0;
+      radius.set(ch, r0 + bl);
+      setR(ch);
     }
+  })(root);
+
+  // Enrich pd rows with angle, r, x, y
+  for (const d of pd) {
+    const th = angle.get(d.thisId) ?? 0;
+    const r  = radius.get(d.thisId) ?? 0;
+    d.angle = th;
+    d.r = r;
+    d.x = r * Math.cos(th);
+    d.y = r * Math.sin(th);
   }
 
-  // at this point the first element is the root
-  pd[0].r = 0;
-  pd[0].x = 0;
-  pd[0].y = 0;
-
-  // return the original sorted data
-  //pd.sort((a,b) => a.thisId - b.thisId)
-
   return pd;
-}
+}

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,89 +2,56 @@ 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) {
-  // phylodata layout...
-  var pd = fortify(node);
-  // set y to null... not needed here.
-  pd.map(d => d.y = null);
-  // where y corresponds to a tip, return tip number
-  // make y0 and y1 equal.
-  var tipID = 1;
-  for (let i = 0; i < pd.length; i++) {
-    if (pd[i].isTip === true) {
-      pd[i].y0 = tipID;
-      pd[i].y1 = tipID;
-      tipID += 1;
+export default function getHorizontal(node) {
+  const pd = fortify(node);
+
+  // Fast lookup from id -> pd index
+  const idIndex = new Map(pd.map((d, i) => [d.thisId, i]));
+
+  // 1) Leaf order from the INPUT TREE (respects your child order / ladderize)
+  const leafIds = [];
+  (function dfs(n) {
+    if (!n.children || n.children.length === 0) { leafIds.push(n.id); return; }
+    n.children.forEach(dfs);
+  })(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; internal node Y via children mean
+  (function setY(n) {
+    const i = idIndex.get(n.id);
+    if (!n.children || n.children.length === 0) {
+      const y = tipSlot.get(n.id);
+      pd[i].y0 = y; pd[i].y1 = y;
+      return y;
     }
-  }
+    const ys = n.children.map(setY);
+    const y = mean(ys);
+    pd[i].y0 = y; pd[i].y1 = y;
+    return y;
+  })(node);
+
+  // 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;
+    const x0 = xParent ?? 0;
+    const x1 = x0 + bl;
+    pd[i].x0 = x0; pd[i].x1 = x1;
+    if (n.children && n.children.length) n.children.forEach(c => setX(c, x1));
+  })(node, 0);
+
+  // 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;
+  });
+}
 
-  // probably incredibly inefficient for large trees.
-  // gets the y values of two child branches by looping through the whole tree...
-  function yVals(child_1, child_2) {
-    for (var i = 0; i < pd.length; i++) {
-      if (pd[i].thisId === child_1) {
-        var y1 = pd[i].y0;
-      }
-      if (pd[i].thisId === child_2) {
-        var y2 = pd[i].y0;
-      }
-    }
-    return mean(([y1, y2]))
-  }
-
-  // if the node is not a tip...
-  for (let i = 0; i < pd.length; i++) {
-    if (pd[i].isTip === false) {
-      // then y0 === y1 and is the mean of the parental nodes
-      pd[i].y0 = yVals(pd[i].children[0], pd[i].children[1]);
-      pd[i].y1 = yVals(pd[i].children[0], pd[i].children[1]);
-    }
-  }
-
-  // find root
-  var root = pd.map(d => d.parentId === null ? d.thisId : null).filter(d => d != null)[0];
-
-  // sort the data temporarily in decreasing parentId
-  pd.sort((a, b) => b.thisId - a.thisId);
-
-  // get the branchlength of the parentID
-  function getParentBranchLength(current_parentId) {
-    for (var i = 0; i < pd.length; i++) {
-      if (pd[i].thisId === current_parentId) {
-        var branchLength = pd[i].x1;
-      }
-    }
-    return branchLength;
-  }
-
-  // last loop...
-  // now get the x0 and x1 coordinates.
-  for (let i = 0; i < pd.length; i++) {
-    // special cases where parent is the root.
-    if (pd[i].parentId === root) {
-      // x0 = 0 and x1 is branch length
-      pd[i].x0 = 0;
-      pd[i].x1 = pd[i].branchLength;
-    } else {
-      // the x0 is that of the parent
-      var parent_branchLength = getParentBranchLength(pd[i].parentId);
-      pd[i].x0 = parent_branchLength;
-      // the x1 is the sum of parent and current branchlength
-      pd[i].x1 = parent_branchLength + pd[i].branchLength;
-    }
-  }
-
-  // return the original sorted data
-  pd.sort((a, b) => a.thisId - b.thisId);
-
-  // remove root?
-
-  // finally get rid of unwanted y, x and angle properties
-  /* eslint-disable no-unused-vars */
-  return pd.map(({ y, x, angle, ...item }) => item);
-  /* eslint-enable no-unused-vars */
-}

package/src/rectangle/getVertical.js

@@ -1,41 +1,36 @@
 import getHorizontal from "./getHorizontal.js"
 
-/**
- * Get the vertical lines to draw.
- */
-
-export default function (node) {
-  var data = getHorizontal(node);
-
-  // for the current iteration of the loop find the matching parentId
-  // then take the difference
-  function findPairs(current_node) {
-    for (var i = 0; i < data.length; i++) {
-      if (data[i].parentId === current_node.parentId) {
-        var height = Math.abs(data[i].y0 - current_node.y0);
-      }
-    }
-    return height;
+export default function getVertical(node) {
+  const data = getHorizontal(node);
+
+  // Group rows by parentId (children that share a parent)
+  const byParent = new Map();
+  for (const row of data) {
+    if (row.parentId == null) continue;
+    const a = byParent.get(row.parentId);
+    if (a) a.push(row); else byParent.set(row.parentId, [row]);
   }
 
-  var verticals = [];
-  // find root
-  var root = data.map(d => d.parentId === null ? d.thisId : null).filter(d => d != null)[0];
-
-  for (var i = 0; i < data.length; i++) {
-    if (data[i].thisId !== root) {
-
-      verticals.push({
-        'thisId': data[i].thisId,
-        'x0': data[i].x0,
-        'x1': data[i].x0, // x values remain constant
-        'y0': data[i].y0,
-        'y1': data[i].y0 + findPairs(data[i]),
-        'heights': findPairs(data[i])
-      })
-
-    }
+  const verticals = [];
+  for (const [parentId, kids] of byParent.entries()) {
+    if (!kids.length) continue;
+    // Works for binary and multifurcations:
+    const yvals = kids.map(d => d.y0);
+    const y0 = Math.min(...yvals);
+    const y1 = Math.max(...yvals);
+    // All children share the same junction x (their x0)
+    const x = kids[0].x0;
+
+    verticals.push({
+      parentId,
+      x0: x,
+      x1: x,
+      y0,
+      y1,
+      heights: y1 - y0
+    });
   }
 
   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;
-}
+}