@mark1russell7/highways 0.3.0 → 0.4.1

package/src/bench/screen/set.ts

@@ -0,0 +1,136 @@
+import { hubChainBoard, manyGroupsBoard, packedGridBoard } from "../../cases.ts";
+import { FIXTURES, makeFixture, type FixtureSpec } from "../../fixtures.ts";
+import type { Graph } from "../../model.ts";
+import { familySeed } from "../suite.ts";
+import { graphInput, type LayoutCell, type LayoutGenerator, type LayoutInput } from "./forms.ts";
+
+/** A family of boards of a screen set. The member `k` of the family has the seed `k`. */
+export interface ScreenFamily {
+  readonly name: string;
+  /** The known hard case that the family shows, in a few words. */
+  readonly shows: string;
+  /** The number of members. */
+  readonly seeds: number;
+  /** This function makes the member `k`. The same `k` always gives the same graph. */
+  readonly make: (k: number) => Graph;
+  /** This function gives the generator of the member `k`: its name, version, parameters and seed. */
+  readonly generator: (k: number) => LayoutGenerator;
+  /** The cell of each member in the taxonomy of the corpus. */
+  readonly cell: LayoutCell;
+}
+
+/** A screen set: a fixed list of small boards with an id. A new board or a changed board gets a new id. */
+export interface ScreenSet {
+  /** The id of the set, for example `screen-v1`. The records name it in `set` and `corpus`. */
+  readonly id: string;
+  readonly families: readonly ScreenFamily[];
+}
+
+const fixture = (name: string): FixtureSpec => FIXTURES.find((f) => f.name === name)!;
+const DENSE: FixtureSpec = { name: "dense-groups", kind: "clustered", nodes: 150, edgesPerNode: 2, seed: 3 };
+const PACKED = { cols: 12, rows: 8, long: 48 } as const;
+
+/** This function gives a family of `makeFixture`. The member `k` has the seed `familySeed(spec, k)`, as in `runSuite`. */
+function fixtureFamily(spec: FixtureSpec, shows: string, seeds: number, cell: LayoutCell): ScreenFamily {
+  const { name, seed: _seed, ...params } = spec;
+  return {
+    name,
+    shows,
+    seeds,
+    cell,
+    make: (k) => makeFixture({ ...spec, seed: familySeed(spec, k) }),
+    generator: (k) => ({ name: "fixture", version: 1, params, seed: familySeed(spec, k) }),
+  };
+}
+
+/** The cell dimensions that each family of `screen-v1` shares. */
+const BASE = { containerSize: "freeAspect", containerShape: "rect", obstacles: "none", mode: "offline", groups: "none" } as const;
+
+/**
+ * The screen set `screen-v1`: 14 boards of made-up data from 10 to 150 nodes. Each family shows a known hard case.
+ * The seed 0 of each family is the fixture or the case board of the benchmark. The seed `k` of a fixture family is `familySeed(spec, k)`, as in `runSuite`.
+ * The generators wrap the fixtures and the case boards without a change to their output.
+ * This set does not change. The tests compare it with the files in `corpus/screen-v1`.
+ */
+export const SCREEN_V1: ScreenSet = {
+  id: "screen-v1",
+  families: [
+    fixtureFamily(fixture("tiny-uniform"), "A tiny board: the cost of a strategy at its start.", 3, { ...BASE, count: "10", edgeDensity: "medium", edgeShape: "random", ports: "free" }),
+    fixtureFamily(fixture("small-clustered"), "Clusters, and fixed plugs on 20% of the nodes.", 3, { ...BASE, count: "100", edgeDensity: "medium", edgeShape: "clustered", ports: "fixed" }),
+    fixtureFamily(DENSE, "Dense groups whose boxes overlap at the far view.", 3, { ...BASE, count: "100", edgeDensity: "medium", edgeShape: "clustered", ports: "free" }),
+    {
+      name: "hub-chain",
+      shows: "A chain of hubs: routes climb away from their targets.",
+      seeds: 1,
+      cell: { ...BASE, count: "100", edgeDensity: "medium", edgeShape: "hubChain", ports: "free" },
+      make: () => hubChainBoard(),
+      generator: () => ({ name: "case.hub-chain", version: 1, params: {}, seed: 3 }),
+    },
+    {
+      name: "many-groups",
+      shows: "Many groups: level links go around the board.",
+      seeds: 1,
+      cell: { ...BASE, count: "100", edgeDensity: "medium", edgeShape: "clustered", ports: "free" },
+      make: () => manyGroupsBoard(),
+      generator: () => ({ name: "case.many-groups", version: 1, params: {}, seed: 7 }),
+    },
+    {
+      name: "packed-grid",
+      shows: "A packed grid: boxes touch, with no channel for the routes.",
+      seeds: 3,
+      cell: { ...BASE, count: "100", edgeDensity: "medium", edgeShape: "longRange", ports: "free" },
+      make: (k) => packedGridBoard({ ...PACKED, seed: 11 + 1009 * k }),
+      generator: (k) => ({ name: "case.packed-grid", version: 1, params: PACKED, seed: 11 + 1009 * k }),
+    },
+  ],
+};
+
+/** The screen sets by id. */
+export const SCREEN_SETS: Readonly<Record<string, ScreenSet>> = { [SCREEN_V1.id]: SCREEN_V1 };
+
+/** This function gives the id of the member `seed` of a family of a set: `<set>/<family>/s<seed>`. */
+export function inputId(set: string, family: string, seed: number): string {
+  return `${set}/${family}/s${seed}`;
+}
+
+/** This function gives the input files of a screen set, in the order of its families and seeds. Each file has its hash. */
+export function screenInputs(set: ScreenSet = SCREEN_V1): LayoutInput[] {
+  return set.families.flatMap((f) =>
+    Array.from({ length: f.seeds }, (_, k) => graphInput(f.make(k), { id: inputId(set.id, f.name, k), set: set.id, family: f.name, seed: k, generator: f.generator(k), cell: f.cell })),
+  );
+}
+
+/** A spec of a manifest: one generator with its version and parameters, and the seeds that the corpus uses. */
+export interface CorpusSpec {
+  readonly generator: string;
+  readonly version: number;
+  readonly params: Readonly<Record<string, unknown>>;
+  readonly seeds: readonly number[];
+}
+
+/** The manifest `corpus.json` of a corpus, of the form `layout-corpus/1`. */
+export interface LayoutCorpus {
+  readonly schema: "layout-corpus/1";
+  readonly corpus: string;
+  readonly specs: readonly CorpusSpec[];
+  readonly inputs: readonly { readonly id: string; readonly hash: string; readonly cell: LayoutCell }[];
+}
+
+/** This function gives the manifest of a list of inputs. The inputs of one generator, version and parameters share one spec. */
+export function corpusManifest(corpus: string, inputs: readonly LayoutInput[]): LayoutCorpus {
+  const specs = new Map<string, { generator: string; version: number; params: Readonly<Record<string, unknown>>; seeds: number[] }>();
+  for (const input of inputs) {
+    const g = input.generator;
+    if (!g) continue;
+    const key = JSON.stringify([g.name, g.version, g.params]);
+    const spec = specs.get(key) ?? { generator: g.name, version: g.version, params: g.params, seeds: [] };
+    if (!spec.seeds.includes(g.seed)) spec.seeds.push(g.seed);
+    specs.set(key, spec);
+  }
+  return {
+    schema: "layout-corpus/1",
+    corpus,
+    specs: [...specs.values()],
+    inputs: inputs.map((i) => ({ id: i.id, hash: i.hash, cell: i.cell ?? {} })),
+  };
+}

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 };
+}