@mark1russell7/highways 0.4.2 → 0.5.1

package/src/highways/spectral/index.ts

@@ -0,0 +1,391 @@
+import type { Point } from "../../geom.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import { compatibility } from "../hdbscan/index.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `spectral` (HWY-029 of the note on highways). */
+export interface SpectralOptions {
+  /** Two edges are a pair of the graph only when their compatibility is this value or more. The default is 0.5. */
+  readonly c0: number;
+  /** The number of clusters of each part of the graph. The value 0 lets the largest eigengap choose it. The default is 0. */
+  readonly clusters: number;
+  /** The eigengap chooses at most this number of clusters in each part of the graph. The default is 16. */
+  readonly kMax: number;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `trunk`: one trunk from one area to the other area. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `spectral`. */
+export const SPECTRAL_DEFAULTS: Readonly<SpectralOptions> = Object.freeze({ c0: 0.5, clusters: 0, kMax: 16, minSize: 2, spine: "trunk" });
+
+/** The largest number of edges in one part of the graph. A larger part splits into blocks of edges in the order of their sources. */
+const BLOCK = 400;
+
+/** The ends of one edge of the board. */
+export interface EdgeEnds {
+  readonly edge: string;
+  readonly s: Point;
+  readonly t: Point;
+}
+
+/** This function gives the ends of each edge of the input: the points of its two plugs. */
+export function edgeEnds(input: HighwayInput): EdgeEnds[] {
+  return edgePlugs(input.graph).map(({ edge, ps, pt }) => ({ edge: edge.id, s: ps.point, t: pt.point }));
+}
+
+/**
+ * This function gives the eigenvalues and the eigenvectors of a symmetric matrix of `n` rows (the Householder steps and the QL steps of JAMA).
+ * The values are in increasing order. The column `j` of `vectors` (the values `vectors[i * n + j]`) is the unit vector of the value `j`.
+ */
+export function symmetricEigen(n: number, a: Float64Array): { values: Float64Array; vectors: Float64Array } {
+  const V = Float64Array.from(a);
+  const d = new Float64Array(n);
+  const e = new Float64Array(n);
+  if (n === 0) return { values: d, vectors: V };
+  if (n === 1) return { values: Float64Array.of(a[0]!), vectors: Float64Array.of(1) };
+  const at = (i: number, j: number): number => V[i * n + j]!;
+  const set = (i: number, j: number, v: number): void => {
+    V[i * n + j] = v;
+  };
+  // The reduction to a tridiagonal matrix.
+  for (let j = 0; j < n; j++) d[j] = at(n - 1, j);
+  for (let i = n - 1; i > 0; i--) {
+    let scale = 0;
+    let h = 0;
+    for (let k = 0; k < i; k++) scale += Math.abs(d[k]!);
+    if (scale === 0) {
+      e[i] = d[i - 1]!;
+      for (let j = 0; j < i; j++) {
+        d[j] = at(i - 1, j);
+        set(i, j, 0);
+        set(j, i, 0);
+      }
+    } else {
+      for (let k = 0; k < i; k++) {
+        d[k] = d[k]! / scale;
+        h += d[k]! * d[k]!;
+      }
+      let f = d[i - 1]!;
+      let g = Math.sqrt(h);
+      if (f > 0) g = -g;
+      e[i] = scale * g;
+      h -= f * g;
+      d[i - 1] = f - g;
+      for (let j = 0; j < i; j++) e[j] = 0;
+      for (let j = 0; j < i; j++) {
+        f = d[j]!;
+        set(j, i, f);
+        g = e[j]! + at(j, j) * f;
+        for (let k = j + 1; k <= i - 1; k++) {
+          g += at(k, j) * d[k]!;
+          e[k] = e[k]! + at(k, j) * f;
+        }
+        e[j] = g;
+      }
+      f = 0;
+      for (let j = 0; j < i; j++) {
+        e[j] = e[j]! / h;
+        f += e[j]! * d[j]!;
+      }
+      const hh = f / (h + h);
+      for (let j = 0; j < i; j++) e[j] = e[j]! - hh * d[j]!;
+      for (let j = 0; j < i; j++) {
+        f = d[j]!;
+        g = e[j]!;
+        for (let k = j; k <= i - 1; k++) set(k, j, at(k, j) - (f * e[k]! + g * d[k]!));
+        d[j] = at(i - 1, j);
+        set(i, j, 0);
+      }
+    }
+    d[i] = h;
+  }
+  for (let i = 0; i < n - 1; i++) {
+    set(n - 1, i, at(i, i));
+    set(i, i, 1);
+    const h = d[i + 1]!;
+    if (h !== 0) {
+      for (let k = 0; k <= i; k++) d[k] = at(k, i + 1) / h;
+      for (let j = 0; j <= i; j++) {
+        let g = 0;
+        for (let k = 0; k <= i; k++) g += at(k, i + 1) * at(k, j);
+        for (let k = 0; k <= i; k++) set(k, j, at(k, j) - g * d[k]!);
+      }
+    }
+    for (let k = 0; k <= i; k++) set(k, i + 1, 0);
+  }
+  for (let j = 0; j < n; j++) {
+    d[j] = at(n - 1, j);
+    set(n - 1, j, 0);
+  }
+  set(n - 1, n - 1, 1);
+  e[0] = 0;
+  // The QL steps with implicit shifts.
+  for (let i = 1; i < n; i++) e[i - 1] = e[i]!;
+  e[n - 1] = 0;
+  let f = 0;
+  let tst1 = 0;
+  const eps = 2 ** -52;
+  for (let l = 0; l < n; l++) {
+    tst1 = Math.max(tst1, Math.abs(d[l]!) + Math.abs(e[l]!));
+    let m = l;
+    while (m < n - 1 && Math.abs(e[m]!) > eps * tst1) m++;
+    if (m > l) {
+      for (let iter = 0; iter < 64; iter++) {
+        let g = d[l]!;
+        let p = (d[l + 1]! - g) / (2 * e[l]!);
+        let r = Math.hypot(p, 1);
+        if (p < 0) r = -r;
+        d[l] = e[l]! / (p + r);
+        d[l + 1] = e[l]! * (p + r);
+        const dl1 = d[l + 1]!;
+        let h = g - d[l]!;
+        for (let i = l + 2; i < n; i++) d[i] = d[i]! - h;
+        f += h;
+        p = d[m]!;
+        let c = 1;
+        let c2 = c;
+        let c3 = c;
+        const el1 = e[l + 1]!;
+        let s = 0;
+        let s2 = 0;
+        for (let i = m - 1; i >= l; i--) {
+          c3 = c2;
+          c2 = c;
+          s2 = s;
+          g = c * e[i]!;
+          h = c * p;
+          r = Math.hypot(p, e[i]!);
+          e[i + 1] = s * r;
+          s = e[i]! / r;
+          c = p / r;
+          p = c * d[i]! - s * g;
+          d[i + 1] = h + s * (c * g + s * d[i]!);
+          for (let k = 0; k < n; k++) {
+            const hk = at(k, i + 1);
+            set(k, i + 1, s * at(k, i) + c * hk);
+            set(k, i, c * at(k, i) - s * hk);
+          }
+        }
+        p = (-s * s2 * c3 * el1 * e[l]!) / dl1;
+        e[l] = s * p;
+        d[l] = c * p;
+        if (Math.abs(e[l]!) <= eps * tst1) break;
+      }
+    }
+    d[l] = d[l]! + f;
+    e[l] = 0;
+  }
+  // The values in increasing order, with their vectors.
+  for (let i = 0; i < n - 1; i++) {
+    let k = i;
+    let p = d[i]!;
+    for (let j = i + 1; j < n; j++)
+      if (d[j]! < p) {
+        k = j;
+        p = d[j]!;
+      }
+    if (k !== i) {
+      d[k] = d[i]!;
+      d[i] = p;
+      for (let j = 0; j < n; j++) {
+        const t = at(j, i);
+        set(j, i, at(j, k));
+        set(j, k, t);
+      }
+    }
+  }
+  return { values: d, vectors: V };
+}
+
+/**
+ * This function puts the rows of a matrix of `n` rows and `k` columns into `k` clusters (the steps of Lloyd).
+ * The first centre is row 0. Each next centre is the row farthest from the centres that exist. The result is the cluster of each row.
+ */
+export function kMeans(n: number, k: number, rows: Float64Array, iterations = 50): Int32Array {
+  const label = new Int32Array(n);
+  if (k <= 1 || n <= 1) return label;
+  const dim = rows.length / n;
+  const d2 = (i: number, c: Float64Array, ci: number): number => {
+    let s = 0;
+    for (let j = 0; j < dim; j++) {
+      const v = rows[i * dim + j]! - c[ci * dim + j]!;
+      s += v * v;
+    }
+    return s;
+  };
+  const centres = new Float64Array(k * dim);
+  for (let j = 0; j < dim; j++) centres[j] = rows[j]!;
+  const near = new Float64Array(n).fill(Infinity);
+  let count = 1;
+  for (; count < k; count++) {
+    let far = -1;
+    let best = -1;
+    for (let i = 0; i < n; i++) {
+      near[i] = Math.min(near[i]!, d2(i, centres, count - 1));
+      if (near[i]! > best) [best, far] = [near[i]!, i];
+    }
+    if (best <= 1e-12) break;
+    for (let j = 0; j < dim; j++) centres[count * dim + j] = rows[far * dim + j]!;
+  }
+  for (let iter = 0; iter < iterations; iter++) {
+    let moved = false;
+    for (let i = 0; i < n; i++) {
+      let c = 0;
+      let best = Infinity;
+      for (let ci = 0; ci < count; ci++) {
+        const v = d2(i, centres, ci);
+        if (v < best - 1e-12) [best, c] = [v, ci];
+      }
+      if (label[i] !== c) [label[i], moved] = [c, true];
+    }
+    if (!moved && iter > 0) break;
+    const sums = new Float64Array(count * dim);
+    const sizes = new Int32Array(count);
+    for (let i = 0; i < n; i++) {
+      sizes[label[i]!]!++;
+      for (let j = 0; j < dim; j++) sums[label[i]! * dim + j] = sums[label[i]! * dim + j]! + rows[i * dim + j]!;
+    }
+    for (let ci = 0; ci < count; ci++) if (sizes[ci]! > 0) for (let j = 0; j < dim; j++) centres[ci * dim + j] = sums[ci * dim + j]! / sizes[ci]!;
+  }
+  return label;
+}
+
+/**
+ * This function gives the spectral clusters of the points of a weight matrix (von Luxburg 2007, with the normalization of Ng, Jordan and Weiss).
+ * Each connected part of the graph is one problem. `L_sym = I - D^-1/2 W D^-1/2`.
+ * The number of clusters `k` of a part is `clusters`, or the place of the largest gap of the first `kMax + 1` eigenvalues.
+ * The first `k` eigenvectors, with each row at the length 1, go into `kMeans`. The result is the cluster of each point, and -1 for a point with no pair.
+ */
+export function spectralLabels(n: number, w: Float64Array, o: Readonly<Pick<SpectralOptions, "clusters" | "kMax">>): Int32Array {
+  const labels = new Int32Array(n).fill(-1);
+  // The connected parts of the graph.
+  const part = new Int32Array(n).fill(-1);
+  const parts: number[][] = [];
+  for (let i = 0; i < n; i++) {
+    if (part[i]! >= 0) continue;
+    let alone = true;
+    for (let j = 0; j < n && alone; j++) if (j !== i && w[i * n + j]! > 0) alone = false;
+    if (alone) continue;
+    const list = [i];
+    part[i] = parts.length;
+    for (let q = 0; q < list.length; q++) {
+      const a = list[q]!;
+      for (let b = 0; b < n; b++)
+        if (part[b]! < 0 && b !== a && w[a * n + b]! > 0) {
+          part[b] = parts.length;
+          list.push(b);
+        }
+    }
+    list.sort((x, y) => x - y);
+    parts.push(list);
+  }
+  let next = 0;
+  for (const list of parts) {
+    const m = list.length;
+    if (m <= 2) {
+      for (const i of list) labels[i] = next;
+      next++;
+      continue;
+    }
+    const deg = list.map((i) => list.reduce((s, j) => s + (i === j ? 0 : w[i * n + j]!), 0));
+    const a = new Float64Array(m * m);
+    for (let x = 0; x < m; x++)
+      for (let y = 0; y < m; y++) {
+        const v = x === y ? 0 : w[list[x]! * n + list[y]!]! / Math.sqrt(deg[x]! * deg[y]!);
+        a[x * m + y] = (x === y ? 1 : 0) - v;
+      }
+    const { values, vectors } = symmetricEigen(m, a);
+    let k = Math.max(1, Math.min(m, Math.round(o.clusters)));
+    if (Math.round(o.clusters) <= 0) {
+      k = 1;
+      let gap = -Infinity;
+      const top = Math.max(1, Math.min(Math.round(o.kMax), m - 1));
+      for (let i = 1; i <= top; i++) {
+        const g = values[i]! - values[i - 1]!;
+        if (g > gap + 1e-12) [gap, k] = [g, i];
+      }
+    }
+    if (k <= 1) {
+      for (const i of list) labels[i] = next;
+      next++;
+      continue;
+    }
+    const rows = new Float64Array(m * k);
+    for (let x = 0; x < m; x++) {
+      let len = 0;
+      for (let j = 0; j < k; j++) len += vectors[x * m + j]! ** 2;
+      len = Math.sqrt(len) || 1;
+      for (let j = 0; j < k; j++) rows[x * k + j] = vectors[x * m + j]! / len;
+    }
+    const found = kMeans(m, k, rows);
+    const ids = new Map<number, number>();
+    list.forEach((i, x) => {
+      const c = found[x]!;
+      if (!ids.has(c)) ids.set(c, next++);
+      labels[i] = ids.get(c)!;
+    });
+  }
+  return labels;
+}
+
+/** This function gives the matrix of the compatibility of the pairs of edges, with 0 for a pair below `c0`. Then a `scale` changes the value of each pair that stays. */
+export function compatibilityMatrix(ends: readonly EdgeEnds[], c0: number, scale?: (i: number, j: number) => number): Float64Array {
+  const n = ends.length;
+  const w = new Float64Array(n * n);
+  for (let i = 0; i < n; i++)
+    for (let j = i + 1; j < n; j++) {
+      const raw = compatibility(ends[i]!.s, ends[i]!.t, ends[j]!.s, ends[j]!.t);
+      if (raw < c0) continue;
+      const c = raw * (scale ? scale(i, j) : 1);
+      if (c <= 0) continue;
+      w[i * n + j] = c;
+      w[j * n + i] = c;
+    }
+  return w;
+}
+
+/**
+ * This function gives the edge groups of the clusters of the edges of one matrix. Each edge of a cluster gets `flip` when it goes opposite to the first edge of the cluster.
+ * An edge with the label -1 gets no group.
+ */
+export function labelGroups(ends: readonly EdgeEnds[], labels: Int32Array, prefix: string, groups: Map<string, EdgeGroup>): void {
+  const lead = new Map<number, number>();
+  ends.forEach((e, i) => {
+    const c = labels[i]!;
+    if (c < 0) return;
+    if (!lead.has(c)) lead.set(c, i);
+    const l = ends[lead.get(c)!]!;
+    const flip = (e.t.x - e.s.x) * (l.t.x - l.s.x) + (e.t.y - e.s.y) * (l.t.y - l.s.y) < 0;
+    groups.set(e.edge, { key: `${prefix}${c}`, flip });
+  });
+}
+
+/** This function splits the edges into blocks of at most `BLOCK` edges, in the order of their sources. A small graph is one block. */
+export function edgeBlocks<T extends EdgeEnds>(ends: readonly T[]): T[][] {
+  if (ends.length <= BLOCK) return [[...ends]];
+  const order = [...ends].sort((a, b) => a.s.x - b.s.x || a.s.y - b.s.y || (a.edge < b.edge ? -1 : 1));
+  const out: T[][] = [];
+  for (let from = 0; from < order.length; from += BLOCK) out.push(order.slice(from, from + BLOCK));
+  return out;
+}
+
+/** This function gives the spectral clusters of the edges (HWY-029). A pair of edges is in the graph when its compatibility of FDEB is `c0` or more. */
+export function spectralClusters(input: HighwayInput, o: Readonly<SpectralOptions>): Map<string, EdgeGroup> {
+  const groups = new Map<string, EdgeGroup>();
+  edgeBlocks(edgeEnds(input)).forEach((block, b) => {
+    const labels = spectralLabels(block.length, compatibilityMatrix(block, o.c0), o);
+    labelGroups(block, labels, `p${b}:`, groups);
+  });
+  return groups;
+}
+
+/**
+ * This function gives the highways of the spectral clusters of the compatibility graph (HWY-029). The eigengap gives the number of highways of each part.
+ * The clusters with `minSize` edges or more get highways.
+ */
+export function spectralPlan(input: HighwayInput, o: Readonly<SpectralOptions>): HighwayPlan {
+  return groupedPlan(input, spectralClusters(input, o), { spine: o.spine, minSize: Math.max(2, Math.round(o.minSize)) });
+}

package/src/highways/spiral/index.ts

@@ -0,0 +1,205 @@
+import { center, dist, type Point } from "../../geom.ts";
+import { nodeIndex, type Node } from "../../model.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import { tidyPlan } from "../base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `spiral` (HWY-017 with EDA-035 of the notes). */
+export interface SpiralOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The spiral angle, in degrees: the largest angle between a branch and the line to the root. The default is 25. */
+  readonly alpha: number;
+  /** A node with this number of edges or more gets a spiral tree. The default is 4. */
+  readonly minTargets: number;
+  /** The number of points of the arc of each branch. The default is 4. */
+  readonly arc: number;
+}
+
+/** The default options of the strategy `spiral`. */
+export const SPIRAL_DEFAULTS: Readonly<Required<Omit<SpiralOptions, "margin" | "k">>> = Object.freeze({ alpha: 25, minTargets: 4, arc: 4 });
+
+/** One node of a spiral tree, in polar coordinates around the root. A leaf has an edge, and a join has two children. */
+export interface SpiralNode {
+  readonly r: number;
+  readonly theta: number;
+  readonly point: Point;
+  /** A join with this node is this distance or more nearer to the root than the node. A leaf keeps its box clear so. A join has 0. */
+  readonly clear: number;
+  readonly edge?: string;
+  readonly children: readonly SpiralNode[];
+}
+
+const TAU = 2 * Math.PI;
+
+/** This function gives the angle `t` in the range from 0 to 2 pi. */
+const wrap = (t: number): number => ((t % TAU) + TAU) % TAU;
+
+/**
+ * This function gives the join of the nodes `p` and `q` of a spiral tree with the angle `alpha`. It gives `undefined` when no join is possible.
+ * Each node can reach the points inside its two spirals toward the root: `|theta - theta_p| <= tan(alpha) ln(r_p / r)`.
+ * The join is the point farthest from the root that both nodes reach, and that is `clear` nearer to the root than each node.
+ * At that radius, the join is at the middle of the angles that both nodes reach.
+ */
+export function spiralJoin(p: SpiralNode, q: SpiralNode, alpha: number, root: Point): { r: number; theta: number; point: Point } | undefined {
+  const t = Math.tan(alpha);
+  // The angle from p to q, counterclockwise, in the range from -pi to pi.
+  let delta = wrap(q.theta - p.theta);
+  if (delta > Math.PI) delta -= TAU;
+  const gap = Math.abs(delta);
+  if (gap >= Math.PI || t <= 0) return undefined;
+  const near = p.r <= q.r ? p : q;
+  const far = p.r <= q.r ? q : p;
+  const meet = t * Math.log(far.r / near.r) >= gap ? near.r : Math.exp((Math.log(p.r) + Math.log(q.r) - gap / t) / 2);
+  const r = Math.min(meet, p.r - p.clear, q.r - q.clear);
+  if (!(r > 0)) return undefined;
+  // In the frame where p is at 0 and q is at `gap`, p reaches [-rp, rp] and q reaches [gap - rq, gap + rq].
+  const rp = t * Math.log(p.r / r);
+  const rq = t * Math.log(q.r / r);
+  const lo = Math.max(-rp, gap - rq);
+  const hi = Math.min(rp, gap + rq);
+  if (lo > hi + 1e-9) return undefined;
+  const theta = wrap(p.theta + Math.sign(delta) * ((lo + hi) / 2));
+  return { r, theta, point: { x: root.x + r * Math.cos(theta), y: root.y + r * Math.sin(theta) } };
+}
+
+/**
+ * This function gives the spiral tree of the leaves around the root (Buchin, Speckmann and Verbeek 2011), with the greedy sweep.
+ * The sweep goes from the far leaves to the root. A leaf joins the wavefront at its radius. Two nodes that are next to each other in angle join at their join point.
+ * The join with the largest radius goes first. No join occurs below the radius `rMin`. The function gives the nodes of the wavefront at the end.
+ */
+export function spiralTree(leaves: readonly SpiralNode[], alpha: number, root: Point, rMin: number): SpiralNode[] {
+  const waiting = [...leaves].sort((a, b) => b.r - a.r || (a.edge! < b.edge! ? -1 : 1));
+  const front: SpiralNode[] = [];
+  const insert = (n: SpiralNode): void => {
+    let i = 0;
+    while (i < front.length && front[i]!.theta <= n.theta) i++;
+    front.splice(i, 0, n);
+  };
+  for (;;) {
+    let best: { i: number; r: number; theta: number; point: Point } | undefined;
+    if (front.length >= 2)
+      for (let i = 0; i < front.length; i++) {
+        if (front.length === 2 && i === 1) break;
+        const j = (i + 1) % front.length;
+        const join = spiralJoin(front[i]!, front[j]!, alpha, root);
+        if (join && join.r >= rMin && (!best || join.r > best.r)) best = { i, ...join };
+      }
+    const next = waiting[0];
+    if (next && (!best || next.r >= best.r)) {
+      insert(waiting.shift()!);
+      continue;
+    }
+    if (!best) return front;
+    const i = best.i;
+    const j = (i + 1) % front.length;
+    const node: SpiralNode = { r: best.r, theta: best.theta, point: best.point, clear: 0, children: [front[i]!, front[j]!] };
+    for (const k of [i, j].sort((a, b) => b - a)) front.splice(k, 1);
+    insert(node);
+  }
+}
+
+/** This function gives the leaves under a node of a spiral tree, in the order of the tree. */
+function leavesOf(n: SpiralNode): string[] {
+  return n.edge !== undefined ? [n.edge] : n.children.flatMap(leavesOf);
+}
+
+/**
+ * This function gives the highways of the spiral trees (HWY-017, EDA-035). Each node with `minTargets` edges or more is the root of a fan.
+ * The nodes with more edges go first, and each edge is in one fan at most. The far plug of each edge is a leaf of the tree of its fan.
+ * Each branch of a tree with two leaves or more is a highway. Its spine is an arc of a logarithmic spiral, or a way through the corner graph where the arc hits a box.
+ * An edge rides the branches from the root to its leaf, or from its leaf to the root when the root is its target.
+ */
+export function spiralPlan(input: HighwayInput, o: Readonly<SpiralOptions>): HighwayPlan {
+  const graph = input.graph;
+  const finder = new WayFinder(graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const pad = finder.margin / 2;
+  const byId = nodeIndex(graph);
+  const plugs = edgePlugs(graph);
+  const degree = new Map<string, number>();
+  for (const { edge } of plugs) {
+    if (edge.source.node === edge.target.node) continue;
+    for (const n of [edge.source.node, edge.target.node]) degree.set(n, (degree.get(n) ?? 0) + 1);
+  }
+  const hubs = [...degree].filter(([, d]) => d >= o.minTargets).sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
+  const alpha = (Math.max(1, Math.min(80, o.alpha)) * Math.PI) / 180;
+  const arcPoints = Math.max(2, Math.round(o.arc));
+  const used = new Set<string>();
+  const highways: Highway[] = [];
+
+  /** This function gives the spine from the point `a` to the point `b`. The spine is a spiral arc in free space, or a way through the corner graph. */
+  const spineOf = (root: Point, a: { r: number; theta: number; point: Point }, b: { r: number; theta: number; point: Point }): Point[] | undefined => {
+    if (finder.obstacles.inside(a.point, pad) || finder.obstacles.inside(b.point, pad)) return undefined;
+    let dt = wrap(b.theta - a.theta);
+    if (dt > Math.PI) dt -= TAU;
+    const arc: Point[] = [a.point];
+    for (let s = 1; s < arcPoints - 1; s++) {
+      const u = s / (arcPoints - 1);
+      const r = a.r * Math.pow(b.r / a.r, u);
+      const theta = a.theta + dt * u;
+      arc.push({ x: root.x + r * Math.cos(theta), y: root.y + r * Math.sin(theta) });
+    }
+    arc.push(b.point);
+    if (finder.obstacles.clearPath(arc, pad)) return arc;
+    const way = finder.corners.path(a.point, b.point);
+    return way ? finder.corners.pull(way) : undefined;
+  };
+
+  for (const [hubId] of hubs) {
+    const hub: Node | undefined = byId.get(hubId);
+    if (!hub) continue;
+    const root = center(hub.box);
+    const rMin = Math.hypot(hub.box.w, hub.box.h) / 2 + 2 * finder.margin;
+    const fan = plugs.filter(({ edge }) => !used.has(edge.id) && edge.source.node !== edge.target.node && (edge.source.node === hubId || edge.target.node === hubId));
+    if (fan.length < o.minTargets) continue;
+    const out = new Map<string, boolean>();
+    const near = new Map<string, Point>();
+    const far = new Map<string, Point>();
+    const leaves: SpiralNode[] = fan.map(({ edge, ps, pt }) => {
+      const outward = edge.source.node === hubId;
+      out.set(edge.id, outward);
+      near.set(edge.id, outward ? ps.point : pt.point);
+      const p = outward ? pt.point : ps.point;
+      far.set(edge.id, p);
+      const box = byId.get(outward ? edge.target.node : edge.source.node)!.box;
+      const clear = Math.hypot(box.w, box.h) / 2 + finder.margin;
+      return { r: Math.max(1e-6, dist(root, p)), theta: wrap(Math.atan2(p.y - root.y, p.x - root.x)), point: p, clear, edge: edge.id, children: [] };
+    });
+    for (const { edge } of fan) used.add(edge.id);
+    const tops = spiralTree(leaves, alpha, root, rMin);
+    // The branches: each link from a node to a child with two leaves or more, from the root down.
+    interface Branch {
+      readonly spine: Point[];
+      readonly edges: string[];
+      readonly depth: number;
+    }
+    const branches: Branch[] = [];
+    const walk = (parent: { r: number; theta: number; point: Point }, child: SpiralNode, depth: number): void => {
+      if (child.edge !== undefined) return;
+      const spine = dist(parent.point, child.point) > finder.margin ? spineOf(root, parent, child) : undefined;
+      if (spine && spine.length >= 2) branches.push({ spine, edges: leavesOf(child), depth });
+      for (const c of child.children) if (dist(c.point, child.point) > 1e-9) walk(child, c, depth + 1);
+      // A child at the point of the join (the nearer node of a join) goes on from the same point.
+      for (const c of child.children) if (dist(c.point, child.point) <= 1e-9) for (const g of c.children) walk(child, g, depth + 1);
+    };
+    for (const top of tops) {
+      if (top.edge !== undefined) continue;
+      // The trunk from the hub: it starts at the radius `rMin` on the line to the top node.
+      const start = { r: rMin, theta: top.theta, point: { x: root.x + rMin * Math.cos(top.theta), y: root.y + rMin * Math.sin(top.theta) } };
+      walk(top.r > rMin + finder.margin ? start : top, top, 0);
+    }
+    for (const b of branches) {
+      if (b.edges.length < 2) continue;
+      const last = b.spine.length - 1;
+      const tripOf = (edge: string): Point[] => [near.get(edge)!, ...b.spine, far.get(edge)!];
+      const lanes = orderLanes(
+        b.spine,
+        b.edges.map((edge) => ({ edge, points: tripOf(edge) })),
+        "bundle",
+      );
+      const members: HighwayMember[] = lanes.map((edge) => (out.get(edge) ? memberAt(b.spine, edge, 0, last, b.depth) : memberAt(b.spine, edge, last, 0, -b.depth)));
+      highways.push({ id: `h${highways.length}`, key: `spiral:${hubId}`, spine: b.spine, lanes, members });
+    }
+  }
+  return tidyPlan({ highways });
+}