@mark1russell7/highways 0.4.2 → 0.5.1

package/src/highways/hierarchy/index.ts

@@ -0,0 +1,140 @@
+import { center, type Point } from "../../geom.ts";
+import { cutGroups, kdGroups, quadtreeGroups } from "../../groups/index.ts";
+import type { Section } from "../../sections.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+import { tracePlan } from "../trace.ts";
+
+/** The trees of sections that the strategy `hierarchy` can use. */
+export type HierarchyGroups = "quadtree" | "kd" | "cut";
+
+/** The values of `HierarchyGroups`. */
+export const HIERARCHY_GROUPS: readonly HierarchyGroups[] = Object.freeze(["quadtree", "kd", "cut"]);
+
+/** The options of the highway strategy `hierarchy` (HWY-001 of the notes). */
+export interface HierarchyOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The tree of sections. The default is `quadtree`. */
+  readonly group: HierarchyGroups;
+  /** A section with more nodes splits. The default is 8. */
+  readonly cap: number;
+  /** The pull of the hubs, from 0 to 1 (Holten 2006). The value 0 gives the straight line, and 1 goes through each hub. The default is 0.85. */
+  readonly beta: number;
+  /** The largest number of hubs on each side of the lowest common section. `Infinity` uses all of them. The default is `Infinity`. */
+  readonly hubs: number;
+  /** The side of the grid that the hubs snap to, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `hierarchy`. */
+export const HIERARCHY_DEFAULTS: Readonly<Required<Omit<HierarchyOptions, "margin" | "k">>> = Object.freeze({
+  group: "quadtree",
+  cap: 8,
+  beta: 0.85,
+  hubs: Infinity,
+  snap: 8,
+  minSize: 2,
+});
+
+/** This function gives the tree of sections of the option `group`. */
+function treeOf(input: HighwayInput, group: HierarchyGroups, cap: number): Section {
+  const c = Math.max(1, Math.round(cap));
+  if (group === "kd") return kdGroups(input.graph, { cap: c });
+  if (group === "cut") return cutGroups(input.graph, { cap: c });
+  return quadtreeGroups(input.graph, { cap: c });
+}
+
+/**
+ * This function gives the hub of each section of the tree: the mean of the middles of the boxes of its nodes.
+ * A hub in a box moves to the nearest corner of the corner graph.
+ */
+function hubsOf(input: HighwayInput, root: Section, finder: WayFinder): Map<string, Point> {
+  const middles = input.graph.nodes.map((n) => center(n.box));
+  const hubs = new Map<string, Point>();
+  const visit = (s: Section): void => {
+    if (s.nodes.length > 0) {
+      let x = 0;
+      let y = 0;
+      for (const i of s.nodes) {
+        x += middles[i]!.x;
+        y += middles[i]!.y;
+      }
+      let hub = { x: x / s.nodes.length, y: y / s.nodes.length };
+      if (finder.obstacles.inside(hub, finder.margin / 2)) {
+        const j = finder.corners.nearest(hub);
+        if (j >= 0) hub = finder.corners.points[j]!;
+      }
+      hubs.set(s.id, hub);
+    }
+    for (const c of s.children) visit(c);
+  };
+  visit(root);
+  return hubs;
+}
+
+/** This function gives the chain of sections from the root to the leaf of each node, by the index of the node. */
+function chainsOf(root: Section, count: number): (readonly Section[])[] {
+  const chains: Section[][] = Array.from({ length: count }, () => []);
+  const visit = (s: Section, path: Section[]): void => {
+    const here = [...path, s];
+    if (s.children.length === 0) for (const i of s.nodes) chains[i] = here;
+    for (const c of s.children) visit(c, here);
+  };
+  visit(root, []);
+  return chains;
+}
+
+/**
+ * This function gives the control points of one edge. They are the sections from the leaf of the source up to the lowest common section, then down to the target leaf.
+ * The lowest common section is not in the chain (Holten 2006), so the edges do not all meet at the hub of the root.
+ * `hubs` limits the sections on each side. The sections nearest to the common section stay.
+ */
+export function controlChain(from: readonly Section[], to: readonly Section[], hubs: number): Section[] {
+  let lca = 0;
+  while (lca < from.length && lca < to.length && from[lca]!.id === to[lca]!.id) lca++;
+  // The first sections that differ are at the depth `lca`.
+  const limit = Number.isFinite(hubs) ? Math.max(0, Math.round(hubs)) : Infinity;
+  const up = from.slice(lca, lca + limit).reverse();
+  const down = to.slice(lca, lca + limit);
+  return [...up, ...down];
+}
+
+/**
+ * This function gives the highways of the hierarchical edge bundling (HWY-001, Holten 2006).
+ * The tree of sections gives a hub to each section. Each edge goes near the hubs of the sections between its two leaves.
+ * The waypoint of a hub is `beta hub + (1 - beta) p`, with `p` the point of the straight line at the same share of the chain.
+ * The waypoints snap to a grid of side `snap`, and the ways go through the corner graph. The stretches that `minSize` ways share become highways.
+ */
+export function hierarchyPlan(input: HighwayInput, o: Readonly<HierarchyOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const index = new Map(input.graph.nodes.map((n, i) => [n.id, i] as const));
+  const waypoints = new Map<string, Point[]>();
+  if (input.graph.nodes.length > 0) {
+    const root = treeOf(input, o.group, o.cap);
+    const hubs = hubsOf(input, root, finder);
+    const chains = chainsOf(root, input.graph.nodes.length);
+    const beta = Math.max(0, Math.min(1, o.beta));
+    for (const { edge, ps, pt } of edgePlugs(input.graph)) {
+      const s = index.get(edge.source.node);
+      const t = index.get(edge.target.node);
+      if (s === undefined || t === undefined) continue;
+      const chain = controlChain(chains[s] ?? [], chains[t] ?? [], o.hubs)
+        .map((c) => hubs.get(c.id))
+        .filter((p): p is Point => p !== undefined);
+      if (chain.length === 0) continue;
+      const a = finder.out(ps);
+      const b = finder.out(pt);
+      waypoints.set(
+        edge.id,
+        chain.map((h, i) => {
+          const u = (i + 1) / (chain.length + 1);
+          const line = { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u };
+          return { x: beta * h.x + (1 - beta) * line.x, y: beta * h.y + (1 - beta) * line.y };
+        }),
+      );
+    }
+  }
+  return tracePlan(input, finder, waypoints, { snap: o.snap, minSize: o.minSize, key: "hierarchy" });
+}

package/src/highways/hough/index.ts

@@ -0,0 +1,182 @@
+import { dist, type Point } from "../../geom.ts";
+import type { WayOptions } from "../../ways.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { linePoint, snapPlan, type SnapLine } from "../snap.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `hough` (HWY-024 of the note on highways). */
+export interface HoughOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The width of the votes in the angle, in degrees. An edge joins a peak within this angle. The default is 8. */
+  readonly dTheta: number;
+  /** The width of the votes in the offset, in units of the board. An edge joins a peak when its middle is this near to the line. The default is 12. */
+  readonly dRho: number;
+  /** A peak with fewer edges than this number is not a corridor. The default is 3. */
+  readonly minVotes: number;
+  /** With `true`, the peaks are only horizontal or vertical lines. The default is `false`. */
+  readonly orthogonal: boolean;
+}
+
+/** The default options of the strategy `hough`. */
+export const HOUGH_DEFAULTS: Readonly<Required<Omit<HoughOptions, "margin" | "k">>> = Object.freeze({ dTheta: 8, dRho: 12, minVotes: 3, orthogonal: false });
+
+/** The line of one edge: its direction angle from 0 to pi, its offset along the normal, its middle and its ends. */
+interface EdgeLine {
+  readonly edge: string;
+  readonly theta: number;
+  readonly s: Point;
+  readonly t: Point;
+  readonly mid: Point;
+  readonly len: number;
+}
+
+/** A peak of the votes: its angle, its offset and the sum of its votes. */
+export interface HoughPeak {
+  readonly theta: number;
+  readonly rho: number;
+  readonly votes: number;
+}
+
+const DEG = Math.PI / 180;
+
+/** This function gives the offset of a point from the line through the origin with the direction angle `theta`. */
+const offsetOf = (p: Point, theta: number): number => -p.x * Math.sin(theta) + p.y * Math.cos(theta);
+
+/** This function gives the place of a point along the direction angle `theta`. */
+const placeOf = (p: Point, theta: number): number => p.x * Math.cos(theta) + p.y * Math.sin(theta);
+
+/** This function gives the difference of two direction angles, from 0 to pi / 2. */
+function angleGap(a: number, b: number): number {
+  const d = Math.abs(a - b) % Math.PI;
+  return Math.min(d, Math.PI - d);
+}
+
+/**
+ * This function gives the peaks of the votes of the lines (Duda and Hart 1972). Each line votes for its angle and its offset, with a weight of its length.
+ * A vote spreads as a Gaussian with the widths `dTheta / 2` and `dRho / 2`. The accumulator has bins of 1 degree and of `dRho / 4`.
+ * A peak is a bin with a larger sum than each other bin within `dTheta` and `dRho`. The peaks come in the order of their votes.
+ */
+export function houghPeaks(lines: readonly { theta: number; mid: Point; len: number }[], o: Readonly<Pick<HoughOptions, "dTheta" | "dRho" | "orthogonal">>): HoughPeak[] {
+  if (lines.length === 0) return [];
+  const thetas = o.orthogonal ? [0, 90] : Array.from({ length: 180 }, (_, i) => i);
+  const T = thetas.length;
+  const rhoStep = Math.max(1e-6, o.dRho / 4);
+  let maxRho = 0;
+  for (const l of lines) maxRho = Math.max(maxRho, Math.abs(l.mid.x) + Math.abs(l.mid.y));
+  const R = Math.ceil(maxRho / rhoStep) + 4;
+  const rows = 2 * R + 1;
+  const acc = new Float64Array(T * rows);
+  const wTheta = Math.max(1e-6, o.dTheta);
+  const sT = wTheta / 2;
+  const sR = o.dRho / 2;
+  const reachR = Math.ceil(o.dRho / rhoStep);
+  for (const l of lines) {
+    for (let ti = 0; ti < T; ti++) {
+      const gap = angleGap(thetas[ti]! * DEG, l.theta) / DEG;
+      if (gap > wTheta) continue;
+      const rho = offsetOf(l.mid, thetas[ti]! * DEG);
+      const center = Math.round(rho / rhoStep);
+      const wt = Math.exp(-(gap * gap) / (2 * sT * sT)) * l.len;
+      for (let r = center - reachR; r <= center + reachR; r++) {
+        if (r < -R || r > R) continue;
+        const dr = r * rhoStep - rho;
+        acc[ti * rows + r + R] = acc[ti * rows + r + R]! + wt * Math.exp(-(dr * dr) / (2 * sR * sR));
+      }
+    }
+  }
+  const reachT = o.orthogonal ? 0 : Math.ceil(wTheta);
+  const peaks: HoughPeak[] = [];
+  for (let ti = 0; ti < T; ti++)
+    for (let r = 0; r < rows; r++) {
+      const v = acc[ti * rows + r]!;
+      if (v <= 0) continue;
+      let top = true;
+      for (let dt = -reachT; dt <= reachT && top; dt++)
+        for (let dr = -reachR; dr <= reachR && top; dr++) {
+          if (dt === 0 && dr === 0) continue;
+          let tj = ti + dt;
+          let rj = r - R;
+          // The angle wraps at 180 degrees, and the offset changes its sign there.
+          if (tj < 0) [tj, rj] = [tj + T, -rj];
+          else if (tj >= T) [tj, rj] = [tj - T, -rj];
+          rj += dr;
+          if (rj < -R || rj > R) continue;
+          const w = acc[tj * rows + rj + R]!;
+          // A tie goes to the first bin in the order of the accumulator.
+          if (w > v || (w === v && tj * rows + rj + R < ti * rows + r)) top = false;
+        }
+      if (top) peaks.push({ theta: thetas[ti]! * DEG, rho: (r - R) * rhoStep, votes: v });
+    }
+  peaks.sort((a, b) => b.votes - a.votes || a.theta - b.theta || a.rho - b.rho);
+  return peaks;
+}
+
+/**
+ * This function gives the corridors of the votes (HWY-024). Each edge joins the first peak with an angle within `dTheta` and its middle within `dRho` of the line.
+ * The corridor runs over the common span of the projections of its edges on the line. Each edge snaps to the ends of that span.
+ * A member that makes the span shorter than four margins leaves, while the peak keeps `minVotes` edges.
+ */
+export function houghLines(input: HighwayInput, o: Readonly<HoughOptions>): SnapLine[] {
+  const margin = o.margin ?? 5;
+  const lines: EdgeLine[] = [];
+  for (const { edge, ps, pt } of edgePlugs(input.graph)) {
+    const s = ps.point;
+    const t = pt.point;
+    const len = dist(s, t);
+    if (len <= 1e-9) continue;
+    const theta = (((Math.atan2(t.y - s.y, t.x - s.x) % Math.PI) + Math.PI) % Math.PI);
+    lines.push({ edge: edge.id, theta, s, t, mid: { x: (s.x + t.x) / 2, y: (s.y + t.y) / 2 }, len });
+  }
+  const peaks = houghPeaks(lines, o);
+  const taken = new Set<string>();
+  const out: SnapLine[] = [];
+  const need = Math.max(2, Math.round(o.minVotes));
+  for (const [pi, p] of peaks.entries()) {
+    let members = lines.filter((l) => !taken.has(l.edge) && angleGap(l.theta, p.theta) <= o.dTheta * DEG && Math.abs(offsetOf(l.mid, p.theta) - p.rho) <= o.dRho);
+    const span = (list: readonly EdgeLine[]): [number, number] => {
+      let lo = -Infinity;
+      let hi = Infinity;
+      for (const l of list) {
+        const a = placeOf(l.s, p.theta);
+        const b = placeOf(l.t, p.theta);
+        lo = Math.max(lo, Math.min(a, b));
+        hi = Math.min(hi, Math.max(a, b));
+      }
+      return [lo, hi];
+    };
+    let [lo, hi] = span(members);
+    while (members.length >= need && hi - lo < 4 * margin) {
+      // The member that limits the span the most leaves.
+      let best = -1;
+      let gain = -Infinity;
+      members.forEach((_, i) => {
+        const [l2, h2] = span(members.filter((__, j) => j !== i));
+        if (h2 - l2 > gain) [gain, best] = [h2 - l2, i];
+      });
+      members = members.filter((_, j) => j !== best);
+      [lo, hi] = span(members);
+    }
+    if (members.length < need || hi - lo < 4 * margin) continue;
+    for (const l of members) taken.add(l.edge);
+    const a = linePoint(p.theta, p.rho, lo);
+    const b = linePoint(p.theta, p.rho, hi);
+    out.push({
+      key: `p${pi}`,
+      a,
+      b,
+      members: members.map((l) => {
+        const forward = placeOf(l.s, p.theta) <= placeOf(l.t, p.theta);
+        return { edge: l.edge, from: forward ? a : b, to: forward ? b : a, at: 0 };
+      }),
+    });
+  }
+  return out;
+}
+
+/**
+ * This function gives the highways of the Hough votes (HWY-024). The peaks of the votes of the straight lines of the edges are corridors.
+ * Each corridor is a spine through the corner graph, and its edges ride it over their common span.
+ */
+export function houghPlan(input: HighwayInput, o: Readonly<HoughOptions>): HighwayPlan {
+  const way = { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) };
+  return snapPlan(input, houghLines(input, o), { ...way, minSize: Math.max(2, Math.round(o.minVotes)) });
+}

package/src/highways/hub-arcs/index.ts

@@ -0,0 +1,181 @@
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes, nearestPlace, tidyPlan } from "../base.ts";
+import { lengthBetween, memberAt, pointAt, type Highway, type HighwayInput, type HighwayPlan } from "../model.ts";
+import { candidatePlan, type CandidateSource } from "../select/index.ts";
+import { spinePart } from "../snap.ts";
+import { edgePlugs, sharedStretches } from "../stretches.ts";
+
+/** A generator of candidate arcs: `runs` (the shared stretches of the first ways of all edges) or a generator of the strategy `select`. */
+export type ArcSource = "runs" | CandidateSource;
+
+/** The values of `ArcSource`. */
+export const ARC_SOURCES: readonly ArcSource[] = Object.freeze(["runs", "corridors", "quickbundles", "wspd", "road-classes", "flow-field", "od-cells", "shared-ways"]);
+
+/** The options of the highway strategy `hub-arcs` (HWY-042 of the note on highways). */
+export interface HubArcOptions {
+  /** The largest number of arcs (highways). The default is 12. */
+  readonly q: number;
+  /** The cost of a length on an arc against a length off the arcs, from 0 to 1. The default is 0.5. */
+  readonly alpha: number;
+  /** An edge rides an arc only when its legs plus its part of the arc are this many times its first route or less. The default is 1.25. */
+  readonly stretch: number;
+  /** The number of passes of the local search with one swap. The default is 1. */
+  readonly swaps: number;
+  /** An arc with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+  /** The generators of the candidate arcs. The default is `runs`, `corridors` and `road-classes`. */
+  readonly generators: readonly ArcSource[];
+}
+
+/** The default options of the strategy `hub-arcs`. */
+export const HUB_ARC_DEFAULTS: Readonly<HubArcOptions> = Object.freeze({
+  q: 12,
+  alpha: 0.5,
+  stretch: 1.25,
+  swaps: 1,
+  minSize: 2,
+  generators: Object.freeze(["runs", "corridors", "road-classes"] as ArcSource[]),
+});
+
+/** The largest number of candidate arcs. The longest arcs stay. */
+const MAX_ARCS = 400;
+
+/** The place of one edge on one arc: where it joins and leaves, and the cost it saves against its first route. */
+interface Ride {
+  readonly on: number;
+  readonly off: number;
+  readonly save: number;
+}
+
+/** This function gives the candidate arcs: the spines of the plans of the generators, without the copies, with the longest first. */
+export function candidateArcs(input: HighwayInput, generators: readonly ArcSource[]): Point[][] {
+  const spines: Point[][] = [];
+  for (const g of generators) {
+    const plan = g === "runs" ? runsPlan(input) : candidatePlan(input, g);
+    for (const h of plan.highways) spines.push([...h.spine]);
+  }
+  const seen = new Set<string>();
+  const out: Point[][] = [];
+  for (const s of spines) {
+    if (s.length < 2 || polylineLength(s) <= 1e-6) continue;
+    const key = s.map((p) => `${Math.round(p.x)},${Math.round(p.y)}`).join(";");
+    const back = [...s].reverse().map((p) => `${Math.round(p.x)},${Math.round(p.y)}`).join(";");
+    if (seen.has(key) || seen.has(back)) continue;
+    seen.add(key);
+    out.push(s);
+  }
+  out.sort((a, b) => polylineLength(b) - polylineLength(a));
+  return out.slice(0, MAX_ARCS);
+}
+
+/** This function gives the shared stretches of the first ways of all edges, with no keys. */
+function runsPlan(input: HighwayInput): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes);
+  const ways = edgePlugs(input.graph).map(({ edge, ps, pt }) => {
+    const a = finder.out(ps);
+    const b = finder.out(pt);
+    return { edge: edge.id, key: "", points: finder.corners.path(a, b) ?? [a, b] };
+  });
+  return sharedStretches(ways, { minSize: 2, pull: (p) => finder.corners.pull(p) });
+}
+
+/**
+ * This function gives the highways of the hub arc location (Campbell, Ernst and Krishnamoorthy 2005). It chooses at most `q` arcs from the candidates.
+ * An edge on an arc costs its two legs plus `alpha` times its part of the arc. An edge off the arcs costs its first route.
+ * The greedy step adds the arc that saves the most cost. Then each swap pass changes one chosen arc for one other arc while the saving grows.
+ * Each edge rides the arc that saves the most for it.
+ */
+export function hubArcPlan(input: HighwayInput, o: Readonly<HubArcOptions>): HighwayPlan {
+  const margin = 5;
+  const routes = firstRoutes(input);
+  const plugs = edgePlugs(input.graph);
+  const arcs = candidateArcs(input, o.generators);
+  const q = Math.max(0, Math.round(o.q));
+  if (q === 0 || arcs.length === 0) return { highways: [] };
+  // The saving of each edge on each arc. A saving of 0 means that the edge does not ride the arc.
+  const rides: (Ride | undefined)[][] = arcs.map((spine) =>
+    plugs.map(({ edge, ps, pt }) => {
+      const first = routes.get(edge.id);
+      const base = first ? polylineLength(first) : dist(ps.point, pt.point);
+      const on = nearestPlace(spine, ps.point);
+      const off = nearestPlace(spine, pt.point);
+      const along = lengthBetween(spine, Math.min(on, off), Math.max(on, off));
+      if (along < margin) return undefined;
+      const legs = dist(ps.point, pointAt(spine, on)) + dist(pointAt(spine, off), pt.point);
+      if (legs + along > o.stretch * base) return undefined;
+      const save = base - (legs + o.alpha * along);
+      return save > 0 ? { on, off, save } : undefined;
+    }),
+  );
+  const n = plugs.length;
+  const total = (chosen: readonly number[]): number => {
+    let sum = 0;
+    for (let e = 0; e < n; e++) {
+      let best = 0;
+      for (const a of chosen) best = Math.max(best, rides[a]![e]?.save ?? 0);
+      sum += best;
+    }
+    return sum;
+  };
+  const chosen: number[] = [];
+  while (chosen.length < q) {
+    const now = total(chosen);
+    let pick = -1;
+    let gain = 1e-9;
+    for (let a = 0; a < arcs.length; a++) {
+      if (chosen.includes(a)) continue;
+      const g = total([...chosen, a]) - now;
+      if (g > gain) [gain, pick] = [g, a];
+    }
+    if (pick < 0) break;
+    chosen.push(pick);
+  }
+  for (let pass = 0; pass < Math.round(o.swaps); pass++) {
+    let better = false;
+    for (let i = 0; i < chosen.length; i++) {
+      const now = total(chosen);
+      let pick = -1;
+      let gain = 1e-9;
+      for (let a = 0; a < arcs.length; a++) {
+        if (chosen.includes(a)) continue;
+        const next = chosen.map((x, j) => (j === i ? a : x));
+        const g = total(next) - now;
+        if (g > gain) [gain, pick] = [g, a];
+      }
+      if (pick >= 0) {
+        chosen[i] = pick;
+        better = true;
+      }
+    }
+    if (!better) break;
+  }
+  // Each edge rides its best arc.
+  const riders = new Map<number, { edge: string; ride: Ride; points: Point[] }[]>();
+  plugs.forEach(({ edge, ps, pt }, e) => {
+    let best = -1;
+    for (const a of chosen) if ((rides[a]![e]?.save ?? 0) > (best < 0 ? 0 : rides[best]![e]!.save)) best = a;
+    if (best < 0) return;
+    const ride = rides[best]![e]!;
+    const list = riders.get(best) ?? [];
+    list.push({ edge: edge.id, ride, points: [ps.point, ...spinePart(arcs[best]!, ride.on, ride.off), pt.point] });
+    riders.set(best, list);
+  });
+  const highways: Highway[] = [];
+  for (const a of [...chosen].sort((x, y) => x - y)) {
+    const list = riders.get(a) ?? [];
+    if (list.length < Math.max(2, o.minSize)) continue;
+    const spine = arcs[a]!;
+    const lanes = orderLanes(spine, list.map((r) => ({ edge: r.edge, points: r.points })), "bundle");
+    const byEdge = new Map(list.map((r) => [r.edge, r.ride]));
+    highways.push({
+      id: `h${highways.length}`,
+      key: `a${a}`,
+      spine,
+      lanes,
+      members: lanes.map((edge) => memberAt(spine, edge, byEdge.get(edge)!.on, byEdge.get(edge)!.off)),
+    });
+  }
+  return tidyPlan({ highways });
+}

package/src/highways/index.ts

@@ -19,4 +19,83 @@ export { FLOW_FIELD_DEFAULTS, flowFieldPlan, type FieldEnd, type FlowFieldOption
 export { SplitTree, WSPD_DEFAULTS, wspdGroups, wspdPlan, type SplitCell, type WspdOptions } from "./wspd/index.ts";
 export { OD_CELL_DEFAULTS, odCellPlan, odGroups, type OdCellOptions } from "./od-cells/index.ts";
 export { CANDIDATE_SOURCES, candidatePlan, candidateScore, SELECT_DEFAULTS, selectPlan, type CandidateSource, type SelectOptions } from "./select/index.ts";
+export { MINGLE_DEFAULTS, mingleBundles, minglePlan, type MingleOptions } from "./mingle/index.ts";
+export { SPIRAL_DEFAULTS, spiralJoin, spiralPlan, spiralTree, type SpiralNode, type SpiralOptions } from "./spiral/index.ts";
+export { FLOW_CLUSTER_DEFAULTS, flowClusterPlan, flowClusters, flowDistance, chainClusters, LINKAGES, type FlowClusterOptions, type Linkage } from "./flow-clusters/index.ts";
+export { characteristicPoints, representative, segmentClusters, segmentDistance, TRACLUS_DEFAULTS, traclusPlan, type RouteSegment, type TraclusOptions } from "./traclus/index.ts";
+export { DIFFUSION_DEFAULTS, diffusionPlan, linkDensity, type DiffusionOptions } from "./diffusion/index.ts";
+export { NESTED_DEFAULTS, nestedGroups, nestedPlan, nestingViolations, type NestedOptions } from "./nested/index.ts";
+export { channelOverflows, LANES_DEFAULTS, lanesPlan, type LanesOptions } from "./lanes/index.ts";
+export { GROWTH_DEFAULTS, growthPlan, type GrowthOptions, type GrowthOrder } from "./growth/index.ts";
+export { EDGE_PATH_DEFAULTS, edgePathPlan, edgePaths, type EdgePathOptions, type PathStep } from "./edge-paths/index.ts";
+export { SOFT_KEY_DEFAULTS, softDistance, softKeyClusters, softKeyPlan, type SoftKeyOptions } from "./soft-keys/index.ts";
+export { linePoint, snapPlan, spinePart, type SnapLine, type SnapMember, type SnapOptions } from "./snap.ts";
+export { HOUGH_DEFAULTS, houghLines, houghPeaks, houghPlan, type HoughOptions, type HoughPeak } from "./hough/index.ts";
+export { densityRidges, lineDensity, RIDGE_DEFAULTS, ridgeLines, ridgePlan, type DensityImage, type Ridge, type RidgeOptions, type RidgeSource } from "./ridges/index.ts";
+export { compatibility, EDGE_DISTANCES, HDBSCAN_DEFAULTS, hdbscanClusters, hdbscanLabels, hdbscanPlan, type EdgeDistance, type HdbscanOptions } from "./hdbscan/index.ts";
+export { ARC_SOURCES, candidateArcs, HUB_ARC_DEFAULTS, hubArcPlan, type ArcSource, type HubArcOptions } from "./hub-arcs/index.ts";
+export { boxPush, innerPoints, outOfBoxes, tracePlan, waypointWay, type TraceOptions } from "./trace.ts";
+export { DIVIDED_DEFAULTS, divideHighway, dividedPlan, offsetLine, TRAFFIC_RULES, type DividedOptions, type TrafficRule } from "./divided/index.ts";
+export { controlChain, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, hierarchyPlan, type HierarchyGroups, type HierarchyOptions } from "./hierarchy/index.ts";
+export { FDEB_DEFAULTS, fdebLines, fdebPlan, type FdebOptions } from "./fdeb/index.ts";
+export { boxUnit, clusters1d, MESH_DEFAULTS, meshPlan, meshWaypoints, type MeshOptions } from "./mesh/index.ts";
+export {
+  DENSITY_KERNELS,
+  densityPlan,
+  fft,
+  KDEEB_DEFAULTS,
+  kdeebLines,
+  kdeebPlan,
+  pointDensity,
+  type AdvectionSettings,
+  type DensityGrid,
+  type DensityKernel,
+  type DensitySource,
+  type KdeebOptions,
+} from "./kdeeb/index.ts";
+export { CUBU_DEFAULTS, cubuPlan, type CubuOptions } from "./cubu/index.ts";
+export { MLS_FITS, MLSEB_DEFAULTS, mlsebLines, mlsebPlan, mlsPoint, type MlsebOptions, type MlsFit } from "./mlseb/index.ts";
+export {
+  bigGroups,
+  firstLines,
+  meanLine,
+  nearestOnLine,
+  nearestSkeleton,
+  SBEB_DEFAULTS,
+  sbebLines,
+  sbebPlan,
+  shapeSkeleton,
+  SKELETON_GROUPS,
+  SKELETON_TARGETS,
+  skeletonGroups,
+  type SbebOptions,
+  type ShapeSkeleton,
+  type SkeletonGroups,
+  type SkeletonTarget,
+} from "./sbeb/index.ts";
+export { AREA_DEFAULTS, AREA_WIDTHS, areaPlan, skeletonPath, type AreaOptions, type AreaWidth } from "./areas/index.ts";
+export { bicliqueGroups, CONFLUENT_DEFAULTS, confluentPlan, GROUP_SCOPES, greedyBicliques, nodeLinks, type Biclique, type ConfluentOptions, type GroupScope, type NodeLinks } from "./confluent/index.ts";
+export { jaccardIndex, MODULE_RULES, modulesOf, POWER_DEFAULTS, powerPlan, type ModuleRule, type PowerOptions } from "./power/index.ts";
+export { CROSSBAR_DEFAULTS, crossbarPlan, greedyCrossbars, routeCrossings, type Crossbar, type CrossbarOptions, type RouteCrossing } from "./crossbars/index.ts";
+export { FRECHET_DEFAULTS, frechetBundles, frechetPlan, nextRow, partWithin, samplesOf, type FrechetBundle, type FrechetOptions } from "./frechet/index.ts";
+export {
+  compatibilityMatrix,
+  edgeBlocks,
+  edgeEnds,
+  kMeans,
+  labelGroups,
+  SPECTRAL_DEFAULTS,
+  spectralClusters,
+  spectralLabels,
+  spectralPlan,
+  symmetricEigen,
+  type EdgeEnds,
+  type SpectralOptions,
+} from "./spectral/index.ts";
+export { edgeResistance, RESISTANCE_DEFAULTS, resistanceClusters, resistancePlan, type ResistanceOptions } from "./resistance/index.ts";
+export { LINK_COMMUNITY_DEFAULTS, linkCommunities, linkCommunityGroups, linkCommunityPlan, type LinkCommunityOptions, type LinkEdge } from "./link-communities/index.ts";
+export { cellSteps, nearestCentre, pointGroups, TERRITORY_DEFAULTS, TERRITORY_POINTS, territoryPlan, type CellStep, type TerritoryOptions, type TerritoryPoints } from "./territories/index.ts";
+export { coAssociation, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, consensusGroups, consensusLabels, consensusPlan, type ConsensusLinkage, type ConsensusOptions } from "./consensus/index.ts";
+export { HUB_ALLOCATIONS, HUB_CANDIDATES, hubCandidates, P_HUB_DEFAULTS, pHubPlan, pMedian, type HubAllocation, type HubCandidates, type PHubOptions } from "./p-hub/index.ts";
+export { SCALE_SPACE_DEFAULTS, scaleClusters, scaleSpaceGroups, scaleSpacePlan, type ScaleCluster, type ScaleSpaceOptions } from "./scale-space/index.ts";
 export * from "./gates/index.ts";