@mark1russell7/highways 0.3.0 → 0.4.0

package/src/bench/suite.ts

@@ -6,9 +6,12 @@ import { nodeIndex, type Graph, type Node, type Result } from "../model.ts";
 import { nearestSide, SIDE_NORMAL } from "../plugs.ts";
 import { makeRoom, openGaps, roomLinks } from "../room/index.ts";
 import { sectionsRouter } from "../routers/sections.ts";
+import { byDataGroup } from "../groups/keys/index.ts";
+import { highwayRouterStrategy } from "../highways/router.ts";
 import { checkSections, type Section } from "../sections.ts";
+import { laneRoutes } from "../segments.ts";
 import { STRATEGIES } from "../strategies/builtins.ts";
-import { asRouter, listStrategies, STEPS, type Registry, type Step, type Strategy } from "../strategies/model.ts";
+import { asRouter, listStrategies, STEPS, type LaneBoard, type Registry, type Step, type Strategy } from "../strategies/model.ts";
 import { measureLevelFaults, sumFaults } from "./links.ts";
 import { checkLevels } from "./properties.ts";
 import { ambiguity, inkSaved } from "./measures/bundles.ts";
@@ -172,6 +175,12 @@ export const FRONT_OBJECTIVES: Readonly<Record<Step, readonly Objective[]>> = {
     { key: "C3.median", better: "min" },
     { key: "C6.length", better: "min" },
   ],
+  highway: [
+    { key: "R1.perEdge", better: "min" },
+    { key: "R5.median", better: "min" },
+    { key: "B1.inkSaved", better: "max" },
+    { key: "R4.turn", better: "min" },
+  ],
   room: [
     { key: "M1.area", better: "min" },
     { key: "M4.laneThrough", better: "min" },
@@ -241,6 +250,8 @@ export function routeMeasures(graph: Graph, result: Result, row: BenchRow): Reco
 /** The input of one curve: a route with the normals of its plugs. */
 interface CurveRoute {
   readonly points: readonly { x: number; y: number }[];
+  /** The index of the route in the order of `laneRoutes`, when the curves draw the lanes of a board. */
+  readonly lane?: number;
   readonly startNormal: { x: number; y: number };
   readonly endNormal: { x: number; y: number };
 }
@@ -257,6 +268,11 @@ export interface CurveRunOptions {
   readonly normals: ReadonlySet<string>;
   /** The options of each curve strategy, by its name. A strategy without an entry gets its defaults. */
   readonly curveOptions?: Readonly<Record<string, object>>;
+  /**
+   * With this board, each curve draws the lanes of `laneRoutes` in place of the routes of the result, and each input has its `lane`.
+   * So the curve `highway` bends the lanes of a bundle as one. Without it, each curve draws the routes of the result.
+   */
+  readonly lanes?: LaneBoard;
 }
 
 /** One curve strategy on the routes of one result: the row of the suite and the drawn curves. */
@@ -279,19 +295,24 @@ export function curveRuns(graph: Graph, result: Result, curves: readonly Strateg
   const u = boardUnit(graph);
   const routes: CurveRoute[] = [];
   const ids: string[] = [];
-  for (const r of result.routes) {
+  const board = options.lanes;
+  const source = board ? laneRoutes(board.graph, board.open, board.width, board.maxWidth) : result.routes;
+  source.forEach((r, i) => {
     const e = edges.get(r.edge);
     const s = e && byId.get(e.source.node);
     const t = e && byId.get(e.target.node);
-    if (!s || !t || r.points.length < 2) continue;
+    if (!s || !t || r.points.length < 2) return;
     ids.push(r.edge);
-    routes.push({ points: r.points, startNormal: SIDE_NORMAL[nearestSide(s.box, r.points[0]!)], endNormal: SIDE_NORMAL[nearestSide(t.box, r.points[r.points.length - 1]!)] });
-  }
+    const normals = { startNormal: SIDE_NORMAL[nearestSide(s.box, r.points[0]!)], endNormal: SIDE_NORMAL[nearestSide(t.box, r.points[r.points.length - 1]!)] };
+    routes.push({ points: r.points, ...normals, ...(board ? { lane: i } : {}) });
+  });
   const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
   return curves.map((curve): CurveRun => {
     const own = options.curveOptions?.[curve.name];
     const t0 = now();
-    const drawn = routes.map((r) => curve.run({ points: r.points, startNormal: r.startNormal, endNormal: r.endNormal, space }, own));
+    const drawn = routes.map((r) =>
+      curve.run({ points: r.points, startNormal: r.startNormal, endNormal: r.endNormal, space, ...(board && r.lane !== undefined ? { lane: { board, index: r.lane } } : {}) }, own),
+    );
     const samples = drawn.map((d) => sampleCurve(d, 0.25));
     const ms = now() - t0;
     const t1 = now();
@@ -392,8 +413,8 @@ export function groupRun(
 }
 
 /**
- * This function gives the options of a grouping rule on a fixture. The rule `keys` gets a key from the data of the edges:
- * the collection of the first edge into the node. A node without such an edge is a group alone.
+ * This function gives the options of a grouping rule on a fixture. The rule `keys` gets the string `data.group` of the node.
+ * A node without it gets a key from the data of the edges: the collection of the first edge into the node. A node without such an edge is a group alone.
  */
 export function fixtureGroupOptions(strategy: string, graph: Graph): object {
   if (strategy !== "keys") return {};
@@ -402,7 +423,7 @@ export function fixtureGroupOptions(strategy: string, graph: Graph): object {
     const c = e.data?.["collection"];
     if (typeof c === "string" && !key.has(e.target.node)) key.set(e.target.node, c);
   }
-  return { key: (n: Node) => key.get(n.id) };
+  return { key: (n: Node, i: number) => byDataGroup(n, i) ?? key.get(n.id) };
 }
 
 /**
@@ -424,10 +445,12 @@ export function runSuite(options: SuiteOptions = {}): { report: SuiteReport; ben
   const smooth = new Set(options.smoothCurves ?? ["rounded", "arc", "spline", "smooth", "clothoid", "highway"]);
   const normals = new Set(options.normalCurves ?? ["spline"]);
   const log = options.log ?? ((): void => {});
-  const fixtures = steps.has("router") || steps.has("group") ? (options.fixtures ?? FIXTURES).filter((f) => f.nodes <= max) : [];
+  const fixtures = steps.has("router") || steps.has("group") || steps.has("highway") ? (options.fixtures ?? FIXTURES).filter((f) => f.nodes <= max) : [];
   const routers = steps.has("router") ? listStrategies(registry, "router").filter((s) => options.routers?.includes(s.name) ?? true) : [];
   const curves = steps.has("curve") ? listStrategies(registry, "curve") : [];
   const groups = steps.has("group") ? listStrategies(registry, "group") : [];
+  // The step `highway`: each highway strategy, then `follow`, as one router.
+  const highways = steps.has("highway") ? listStrategies(registry, "highway").map((s) => highwayRouterStrategy(s)) : [];
   const rooms = listStrategies(registry, "room");
   const rows: SuiteRow[] = [];
   const bench: BenchRow[] = [];
@@ -475,6 +498,39 @@ export function runSuite(options: SuiteOptions = {}): { report: SuiteReport; ben
         if (strategy.name === curveRouter && curves.length > 0 && graph.nodes.length <= curveMax)
           rows.push(...curveRuns(graph, result, curves, { fixture: spec.name, seed: k, smooth, normals }).map((c) => c.row));
       }
+      // The step `highway`: the plan of each strategy, routed with `follow`. The measures are the measures of the step `router`.
+      for (const strategy of highways) {
+        if (graph.nodes.length > (strategy.maxNodes ?? Infinity)) continue;
+        const router = asRouter(strategy);
+        const t0 = now();
+        const { row, result } = benchRun(router, spec.name, graph, 2, cellLimit);
+        const ms = now() - t0;
+        const t1 = now();
+        const values: Record<string, number> = routeMeasures(graph, result, row);
+        const measureMs = now() - t1;
+        let extraMs = 0;
+        if (graph.nodes.length <= stabilityMax) {
+          const t2 = now();
+          const s = routeStability(graph, result, router.route(change.graph), { seed });
+          extraMs = now() - t2;
+          values["Z10.mean"] = s.mean;
+          values["Z10.max"] = s.max;
+          values["Z10.moved"] = s.moved;
+        }
+        rows.push({
+          step: "highway",
+          fixture: spec.name,
+          seed: k,
+          strategy: strategy.name,
+          nodes: row.nodes,
+          edges: row.edges,
+          violations: row.violations + (row.deterministic ? 0 : 1),
+          ms,
+          measureMs,
+          extraMs,
+          values,
+        });
+      }
       // The step `group`: the router `sections` with each grouping rule, and the grouping of the changed graph (G9).
       for (const strategy of groups) {
         const opts = fixtureGroupOptions(strategy.name, graph);
@@ -550,7 +606,7 @@ export function runSuite(options: SuiteOptions = {}): { report: SuiteReport; ben
 
 /**
  * This function puts the rows of the suite in the order of one run. It sorts them by fixture family, then by seed.
- * In one seed, the routers come first, and the curves come after the router of the curves. The grouping rules and the room come last.
+ * In one seed, the routers come first, and the curves come after the router of the curves. Then the highway strategies come, and the grouping rules and the room come last.
  * A name that is not in its list goes after the names of the list.
  * The workflow `Bench` uses it to join the reports of its parts.
  */
@@ -572,8 +628,9 @@ export function orderSuiteRows(
   const rank = (r: SuiteRow): [number, number] => {
     if (r.step === "router") return [0, 2 * place(routers, r.strategy) * (curves.length + 1)];
     if (r.step === "curve") return [0, 2 * after * (curves.length + 1) + 1 + place(curves, r.strategy)];
-    if (r.step === "group") return [1, place(names("group"), r.strategy)];
-    return [2, r.strategy === "gutter" ? -1 : place(names("room"), r.strategy)];
+    if (r.step === "highway") return [1, place(names("highway"), r.strategy)];
+    if (r.step === "group") return [2, place(names("group"), r.strategy)];
+    return [3, r.strategy === "gutter" ? -1 : place(names("room"), r.strategy)];
   };
   return rows
     .map((row, i) => ({ row, i, f: place(families, row.fixture), rank: rank(row) }))
@@ -701,6 +758,7 @@ const fmt = (v: number | undefined, d = 3): string => (v === undefined || Number
 /** The columns of the tables of `formatSuite`: the keys of the measures of each step. */
 export const SUITE_COLUMNS: Readonly<Record<Step, readonly string[]>> = {
   router: ["R1.perEdge", "R2.angle", "R2.min", "B1.inkSaved", "R5.median", "R5.q95", "R4.turn", "R11.q05", "B4.ambiguity", "Z10.moved", "Z8.order", "Z7.position", "G8.treeCost"],
+  highway: ["R1.perEdge", "R2.angle", "R2.min", "B1.inkSaved", "R5.median", "R5.q95", "R4.turn", "R11.q05", "B4.ambiguity", "Z10.moved"],
   curve: ["C1.share", "C1.max", "C2.median", "C3.median", "C3.q95", "C6.length"],
   room: ["M1.area", "M4.laneThrough", "crossings", "through", "room-order"],
   group: ["Z4.farItems", "G1.modularity", "G2.cut", "G6.balance", "G8.treeCost", "G9.ari", "Z7.position", "Z8.order", "Z3.through", "treeMs"],

package/src/highways/corridors/index.ts

@@ -0,0 +1,305 @@
+import { center, dist, type Point } from "../../geom.ts";
+import { nodeIndex, type Graph, type Route } from "../../model.ts";
+import { placePlug } from "../../plugs.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/**
+ * The options of the highway strategy `corridors` (HWY-031 of the note on highways).
+ * The options `margin` and `k` set the corner graph of the first ways, when the input has no first routes.
+ */
+export interface CorridorOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two edges join when their common links are this share of the shorter way, or longer. The default is 0.3. */
+  readonly rho: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+  /** The number of hash functions of the MinHash signature of a way. The default is 64. */
+  readonly hashes: number;
+  /** The number of bands of the signature. Two ways with one equal band are a candidate pair. The default is 32. */
+  readonly bands: number;
+  /** Two link ends nearer than this grid size are one point. With 0, the default, only equal points are one point. */
+  readonly near: number;
+  /** The gap between two lanes. Two edges join only when their common links are longer than the break-even overlap for this gap. The default is 4. */
+  readonly lane: number;
+}
+
+/** The default options of the strategy `corridors`. */
+export const CORRIDOR_DEFAULTS: Readonly<Required<Omit<CorridorOptions, "margin" | "k">>> = Object.freeze({ rho: 0.3, minSize: 2, hashes: 64, bands: 32, near: 0, lane: 4 });
+
+/**
+ * The break-even overlap of two parallel edges for each unit of the lane gap, with the cost exponent 0.5 of the note.
+ * A shared stretch shorter than this times the gap adds ink.
+ */
+export const BREAK_EVEN: number = Math.sqrt((2 + Math.SQRT2) / (2 - Math.SQRT2));
+
+/** One link of a way: its key, its length and its ends in the order of the way. */
+interface Link {
+  readonly key: string;
+  readonly len: number;
+  /** The snapped first end of the link, in the order of the way. */
+  readonly a: string;
+  /** The index of the first end in the points of the way. */
+  readonly at: number;
+}
+
+/** The first way of an edge, with its links. */
+interface Way {
+  readonly edge: string;
+  readonly points: readonly Point[];
+  readonly links: readonly Link[];
+  /** The length of each link, by its key. */
+  readonly set: ReadonlyMap<string, number>;
+  readonly length: number;
+}
+
+/** This function gives the FNV-1a hash of a string, as an unsigned 32-bit number. */
+function fnv1a(text: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+/** This function mixes the bits of a 32-bit number (the finalizer of MurmurHash3). */
+function mix(x: number): number {
+  let h = x >>> 0;
+  h ^= h >>> 16;
+  h = Math.imul(h, 0x85ebca6b);
+  h ^= h >>> 13;
+  h = Math.imul(h, 0xc2b2ae35);
+  h ^= h >>> 16;
+  return h >>> 0;
+}
+
+/** This function gives the MinHash signature of a set of keys with `count` hash functions. */
+export function minHash(keys: Iterable<string>, count: number): number[] {
+  const sig = new Array<number>(count).fill(0xffffffff);
+  const seeds = Array.from({ length: count }, (_, i) => mix(Math.imul(i + 1, 0x9e3779b9)));
+  for (const key of keys) {
+    const base = fnv1a(key);
+    for (let i = 0; i < count; i++) {
+      const v = mix(base ^ seeds[i]!);
+      if (v < sig[i]!) sig[i] = v;
+    }
+  }
+  return sig;
+}
+
+/**
+ * This function gives the first way of each edge: the way through the corner graph, with the plugs at its ends.
+ * The router `corners` finds the same way before it drops the needless corners.
+ */
+function cornerWays(graph: Graph, options: Pick<WayOptions, "margin" | "k">): Route[] {
+  const byId = nodeIndex(graph);
+  const ways = new WayFinder(graph.nodes, options);
+  const out: Route[] = [];
+  for (const e of graph.edges) {
+    const s = byId.get(e.source.node);
+    const t = byId.get(e.target.node);
+    if (!s || !t) continue;
+    const ps = placePlug(s, e.source, center(t.box));
+    const pt = placePlug(t, e.target, center(s.box));
+    const raw = ways.corners.path(ways.out(ps), ways.out(pt));
+    out.push({ edge: e.id, points: raw ? [ps.point, ...raw, pt.point] : [ps.point, pt.point] });
+  }
+  return out;
+}
+
+/** This function gives the way of a route, with a key for each link. Two links with the same ends, in either order, have one key. */
+function wayOf(route: Route, near: number): Way {
+  const snap = (p: Point): string => (near > 0 ? `${Math.round(p.x / near)},${Math.round(p.y / near)}` : `${p.x},${p.y}`);
+  const links: Link[] = [];
+  const set = new Map<string, number>();
+  let length = 0;
+  for (let i = 1; i < route.points.length; i++) {
+    const p = route.points[i - 1]!;
+    const q = route.points[i]!;
+    const len = dist(p, q);
+    if (len <= 1e-9) continue;
+    const a = snap(p);
+    const b = snap(q);
+    if (a === b) continue;
+    const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+    links.push({ key, len, a, at: i - 1 });
+    if (!set.has(key)) set.set(key, len);
+    length += len;
+  }
+  return { edge: route.edge, points: route.points, links, set, length };
+}
+
+/** This function gives the length of the common links of two ways. */
+function overlap(p: Way, q: Way): number {
+  const [small, large] = p.set.size <= q.set.size ? [p, q] : [q, p];
+  let sum = 0;
+  for (const [key, len] of small.set) if (large.set.has(key)) sum += len;
+  return sum;
+}
+
+/** This function gives the pairs of ways with one equal band of their signatures, as `i * n + j` with `i < j`, in order. */
+function candidates(ways: readonly Way[], hashes: number, bands: number): number[] {
+  const rows = Math.max(1, Math.floor(hashes / Math.max(1, bands)));
+  const count = Math.max(1, Math.floor(hashes / rows));
+  const n = ways.length;
+  const pairs = new Set<number>();
+  const buckets = new Map<string, number[]>();
+  ways.forEach((w, i) => {
+    if (w.set.size === 0) return;
+    const sig = minHash(w.set.keys(), rows * count);
+    for (let b = 0; b < count; b++) {
+      const key = `${b}:${sig.slice(b * rows, (b + 1) * rows).join(",")}`;
+      const list = buckets.get(key);
+      if (list) {
+        for (const j of list) pairs.add(j * n + i);
+        list.push(i);
+      } else buckets.set(key, [i]);
+    }
+  });
+  return [...pairs].sort((a, b) => a - b);
+}
+
+/** This function gives the root of an element of a union-find forest, and shortens the path. */
+function root(parent: number[], i: number): number {
+  while (parent[i] !== i) {
+    parent[i] = parent[parent[i]!]!;
+    i = parent[i]!;
+  }
+  return i;
+}
+
+/**
+ * This function gives the clusters of the ways. Two ways join when their common links are long.
+ * A cluster is a connected part of the joins.
+ * MinHash with bands finds the candidate pairs. The function then measures the overlap of each candidate pair.
+ * Each cluster keeps the order of the ways, and the clusters come in the order of their first way.
+ */
+function corridorClusters(ways: readonly Way[], o: Readonly<CorridorOptions>): number[][] {
+  const n = ways.length;
+  const parent = Array.from({ length: n }, (_, i) => i);
+  const floor = BREAK_EVEN * o.lane;
+  for (const pair of candidates(ways, o.hashes, o.bands)) {
+    const i = Math.floor(pair / n);
+    const j = pair % n;
+    const p = ways[i]!;
+    const q = ways[j]!;
+    if (overlap(p, q) >= Math.max(floor, o.rho * Math.min(p.length, q.length))) {
+      const a = root(parent, i);
+      const b = root(parent, j);
+      if (a !== b) parent[Math.max(a, b)] = Math.min(a, b);
+    }
+  }
+  const groups = new Map<number, number[]>();
+  for (let i = 0; i < n; i++) {
+    const r = root(parent, i);
+    const list = groups.get(r);
+    if (list) list.push(i);
+    else groups.set(r, [i]);
+  }
+  return [...groups.values()].filter((g) => g.length >= 2);
+}
+
+/**
+ * This function gives the highway of a pool of ways, or `undefined`. The core is the way with the most shared length.
+ * The spine is the stretch of the core with the largest saving. Each link of the spine has two ways of the pool or more.
+ * A member is a way of the pool whose links on the spine are long enough, all in one direction.
+ */
+function highwayOf(pool: readonly Way[], o: Readonly<CorridorOptions>): { core: Way; spine: Point[]; members: { way: Way; on: number; off: number }[] } | undefined {
+  const count = new Map<string, number>();
+  for (const w of pool) for (const key of w.set.keys()) count.set(key, (count.get(key) ?? 0) + 1);
+  const gain = (key: string, len: number): number => len * ((count.get(key) ?? 1) - 1);
+  let core: Way | undefined;
+  let best = 0;
+  for (const w of pool) {
+    let g = 0;
+    for (const [key, len] of w.set) g += gain(key, len);
+    if (g > best) [core, best] = [w, g];
+  }
+  if (!core) return undefined;
+  // The best stretch of shared links of the core, by the saving of each link (Kadane on a list with only good values in each stretch).
+  let from = -1;
+  let to = -1;
+  let top = 0;
+  let start = 0;
+  let sum = 0;
+  core.links.forEach((l, i) => {
+    if ((count.get(l.key) ?? 0) < 2) {
+      sum = 0;
+      start = i + 1;
+      return;
+    }
+    sum += gain(l.key, l.len);
+    if (sum > top) [top, from, to] = [sum, start, i];
+  });
+  if (from < 0) return undefined;
+  const chosen = core.links.slice(from, to + 1);
+  // The spine: the first end of each chosen link, then the last end of the last link.
+  const spine: Point[] = [core.points[chosen[0]!.at]!, ...chosen.map((l) => core.points[l.at + 1]!)];
+  const index = new Map<string, number>();
+  chosen.forEach((l, j) => {
+    if (!index.has(l.key)) index.set(l.key, j);
+  });
+  const spineLength = chosen.reduce((s, l) => s + l.len, 0);
+  const floor = BREAK_EVEN * o.lane;
+  const members: { way: Way; on: number; off: number }[] = [];
+  for (const w of pool) {
+    let first = -1;
+    let last = -1;
+    let forward: boolean | undefined;
+    let ok = true;
+    let shared = 0;
+    for (const l of w.links) {
+      const j = index.get(l.key);
+      if (j === undefined) continue;
+      const dir = l.a === chosen[j]!.a;
+      if (forward === undefined) forward = dir;
+      else if (forward !== dir) ok = false;
+      if (first < 0) first = j;
+      else if (forward ? j < last : j > last) ok = false;
+      last = j;
+      shared += l.len;
+    }
+    if (!ok || forward === undefined || shared < Math.max(floor, o.rho * Math.min(w.length, spineLength))) continue;
+    members.push(forward ? { way: w, on: first, off: last + 1 } : { way: w, on: first + 1, off: last });
+  }
+  return { core, spine, members };
+}
+
+/**
+ * This function gives the highways of corridor signatures (HWY-031). Each edge gets a first way: the route of `input.routes`, or its way through the corner graph.
+ * The signature of a way is the set of its links. Two edges join when their common links are at least `rho` times the shorter way, and longer than the break-even overlap.
+ * MinHash with `hashes` hash functions in `bands` bands finds the candidate pairs fast. Union-find gives the clusters.
+ *
+ * In each cluster, the spine is the longest common run of links of the way with the most shared length. Each edge on the spine joins it at its first common link and leaves it at its last one.
+ * The edges of the cluster that are not on the spine make the next highway, while `minSize` of them remain.
+ */
+export function corridorPlan(input: HighwayInput, o: Readonly<CorridorOptions>): HighwayPlan {
+  const routes = input.routes?.routes ?? cornerWays(input.graph, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const known = new Set(input.graph.edges.map((e) => e.id));
+  const ways = routes.filter((r) => known.has(r.edge)).map((r) => wayOf(r, o.near));
+  const highways: Highway[] = [];
+  corridorClusters(ways, o).forEach((cluster, c) => {
+    let pool = cluster.map((i) => ways[i]!);
+    while (pool.length >= Math.max(2, o.minSize)) {
+      const found = highwayOf(pool, o);
+      if (!found) break;
+      const { core, spine, members } = found;
+      if (members.length < Math.max(2, o.minSize)) {
+        // The core does not make a highway. The other ways can still make one.
+        pool = pool.filter((w) => w !== core);
+        continue;
+      }
+      const lanes = orderLanes(spine, members.map((m) => ({ edge: m.way.edge, points: m.way.points })), "bundle");
+      const byEdge = new Map(members.map((m) => [m.way.edge, m]));
+      const list: HighwayMember[] = lanes.map((edge) => {
+        const m = byEdge.get(edge)!;
+        return memberAt(spine, edge, m.on, m.off);
+      });
+      highways.push({ id: `h${highways.length}`, key: `c${c}`, spine, lanes, members: list });
+      const used = new Set(members.map((m) => m.way));
+      pool = pool.filter((w) => !used.has(w));
+    }
+  });
+  return { highways };
+}

package/src/highways/follow.ts

@@ -0,0 +1,155 @@
+import { center, dist, pointBoxDistance, type Point } from "../geom.ts";
+import { fixedPortPoint, nodeIndex, type End, type Graph, type Node, type Result, type Route, type SharedRun } from "../model.ts";
+import { placePlug } from "../plugs.ts";
+import { orderLanes, type RunOrder } from "../segments.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+import { pointAt, type HighwayMember, type HighwayPlan } from "./model.ts";
+
+/** The options of `follow`. */
+export interface FollowOptions extends WayOptions {
+  /**
+   * These routes are the routes of the base router. Each edge outside the plan keeps its route from them.
+   * Without them, or for an edge without a route in them, `follow` routes the edge as the router `corners` does.
+   */
+  readonly routes?: Result;
+  /** The lane order of the shared runs. The default is `bundle`. */
+  readonly laneOrder?: RunOrder;
+}
+
+const SAME = 1e-6;
+
+const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > SAME);
+
+/** This function tells if a polyline holds the points of `part` in a row, in this order. */
+function holdsInOrder(p: readonly Point[], part: readonly Point[]): boolean {
+  for (let i = 0; i + part.length <= p.length; i++) {
+    let ok = true;
+    for (let j = 0; ok && j < part.length; j++) ok = dist(p[i + j]!, part[j]!) <= SAME;
+    if (ok) return true;
+  }
+  return false;
+}
+
+/** This function tells if a polyline holds the points of `part` in a row, in either direction. */
+const holds = (p: readonly Point[], part: readonly Point[]): boolean => holdsInOrder(p, part) || holdsInOrder(p, [...part].reverse());
+
+/**
+ * This function tells if a point of a spine can be the plug of an end. The point is on the box of the node.
+ * When the end has a fixed plug, the point is at that plug.
+ */
+function plugAt(node: Node, end: End, p: Point): boolean {
+  if (pointBoxDistance(p, node.box) > SAME) return false;
+  const fixed = fixedPortPoint(node, end);
+  return fixed === undefined || dist(fixed, p) <= SAME;
+}
+
+/** The stops of one spine: each point of the spine and each merge point and split point, by their place, in order. */
+type Stops = readonly (readonly [at: number, point: Point])[];
+
+/** This function gives the points of the stops from the place `on` to the place `off`. When `on` is larger than `off`, the points go backward. */
+function slice(stops: Stops, on: number, off: number): Point[] {
+  const lo = Math.min(on, off);
+  const hi = Math.max(on, off);
+  const out = stops.filter(([at]) => at >= lo && at <= hi).map(([, p]) => p);
+  return on <= off ? out : out.reverse();
+}
+
+/**
+ * This function routes the edges along a highway plan.
+ *
+ * An edge of a highway goes from its source plug to its merge point. Then it goes along the spine to its split point, and to its target plug.
+ * The ramps go around the boxes through the corner graph (`WayFinder.fromPlug` and `WayFinder.toPlug`).
+ * A spine point on the box of the node is the plug itself. When the end has a fixed plug, the point is at that plug.
+ *
+ * An edge on several highways takes them in the order of `seq`.
+ * A way through the corner graph goes from each split point to the next merge point.
+ * An edge outside the plan keeps its route from `options.routes`, or goes as in the router `corners`.
+ *
+ * The result has a shared run for each stretch of a spine where the same two edges or more go. Each run holds the points of its routes in a row.
+ * The same graph, plan and options give the same result.
+ */
+export function follow(graph: Graph, plan: HighwayPlan, options: FollowOptions = {}): Result {
+  const byId = nodeIndex(graph);
+  const ways = new WayFinder(graph.nodes, options);
+  const base = new Map((options.routes?.routes ?? []).map((r) => [r.edge, r.points]));
+  const lines: Stops[] = plan.highways.map((h) => {
+    const stops = new Map<number, Point>(h.spine.map((p, i) => [i, p]));
+    for (const m of h.members) for (const at of [m.on, m.off]) if (!stops.has(at)) stops.set(at, pointAt(h.spine, at));
+    return [...stops].sort((a, b) => a[0] - b[0]);
+  });
+  const trips = new Map<string, { h: number; m: HighwayMember }[]>();
+  plan.highways.forEach((h, hi) => {
+    for (const m of h.members) {
+      const list = trips.get(m.edge);
+      if (list) list.push({ h: hi, m });
+      else trips.set(m.edge, [{ h: hi, m }]);
+    }
+  });
+  for (const list of trips.values()) list.sort((a, b) => a.m.seq - b.m.seq || a.h - b.h);
+
+  const routes: Route[] = [];
+  for (const e of graph.edges) {
+    const s = byId.get(e.source.node);
+    const t = byId.get(e.target.node);
+    if (!s || !t) continue;
+    const trip = trips.get(e.id);
+    if (!trip) {
+      const known = base.get(e.id);
+      if (known) {
+        routes.push({ edge: e.id, points: known });
+        continue;
+      }
+      const ps = placePlug(s, e.source, center(t.box));
+      const pt = placePlug(t, e.target, center(s.box));
+      routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
+      continue;
+    }
+    const out: Point[] = [];
+    let at: Point | undefined;
+    for (const { h, m } of trip) {
+      const piece = slice(lines[h]!, m.on, m.off);
+      const first = piece[0]!;
+      if (at === undefined) {
+        if (!plugAt(s, e.source, first)) {
+          const ps = placePlug(s, e.source, first);
+          out.push(...(ways.fromPlug(ps, first) ?? [ps.point, first]));
+        }
+      } else if (dist(at, first) > SAME) {
+        const way = ways.corners.path(at, first);
+        out.push(...(way ? ways.corners.pull(way) : [at, first]));
+      }
+      out.push(...piece);
+      at = piece[piece.length - 1]!;
+    }
+    if (at !== undefined && !plugAt(t, e.target, at)) {
+      const pt = placePlug(t, e.target, at);
+      out.push(...(ways.toPlug(at, pt) ?? [at, pt.point]));
+    }
+    routes.push({ edge: e.id, points: dedupe(out) });
+  }
+
+  // The runs: each stretch between two stops of a spine, with the same two edges or more on it, joined with the next stretch of the same edges.
+  const routeOf = new Map(routes.map((r) => [r.edge, r]));
+  const runs: SharedRun[] = [];
+  plan.highways.forEach((h, hi) => {
+    const stops = lines[hi]!;
+    const usersOf = (k: number): string[] =>
+      h.members
+        .filter((m) => routeOf.has(m.edge) && Math.min(m.on, m.off) <= stops[k]![0] && Math.max(m.on, m.off) >= stops[k + 1]![0])
+        .map((m) => m.edge)
+        .sort();
+    let k = 0;
+    while (k < stops.length - 1) {
+      const users = usersOf(k);
+      let end = k + 1;
+      while (end < stops.length - 1 && usersOf(end).join("\u0000") === users.join("\u0000")) end++;
+      const points = dedupe(stops.slice(k, end + 1).map(([, p]) => p));
+      k = end;
+      if (users.length < 2 || points.length < 2) continue;
+      const mine = users.map((id) => routeOf.get(id)!).filter((r) => holds(r.points, points));
+      if (mine.length < 2) continue;
+      runs.push({ id: `r${runs.length}`, key: h.key, points, edges: orderLanes(points, mine, options.laneOrder ?? "bundle") });
+    }
+  });
+  return runs.length > 0 ? { routes, runs } : { routes };
+}

package/src/highways/index.ts

@@ -0,0 +1,7 @@
+export { checkPlan, lengthBetween, memberAt, pointAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "./model.ts";
+export { follow, type FollowOptions } from "./follow.ts";
+export { planOfResult } from "./result.ts";
+export { highwayRouter, highwayRouterStrategy } from "./router.ts";
+export { keysPlan, type KeysOptions } from "./keys/index.ts";
+export { sharedWaysPlan, type SharedWaysOptions } from "./shared-ways/index.ts";
+export { BREAK_EVEN, CORRIDOR_DEFAULTS, corridorPlan, minHash, type CorridorOptions } from "./corridors/index.ts";

package/src/highways/keys/index.ts

@@ -0,0 +1,15 @@
+import { trunksRouter, type TrunksOptions } from "../../routers/trunks.ts";
+import { planOfResult } from "../result.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `keys`: the options of the router `trunks`, without the name and the limit of the benchmark. */
+export type KeysOptions = Omit<TrunksOptions, "name" | "maxNodes">;
+
+/**
+ * This function gives the highways that the router `trunks` decides. A rule gives each edge a key.
+ * The edges from one plug with one key share a trunk to a split point. The edges that go on together share a run past it.
+ * Each trunk and each run becomes one highway. The function does not change the router: it reads its bundles and its runs.
+ */
+export function keysPlan(input: HighwayInput, options: KeysOptions): HighwayPlan {
+  return planOfResult(trunksRouter({ ...options, name: "keys" }).route(input.graph));
+}