@mark1russell7/highways 0.1.4 → 0.1.5

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/src/bench/curves.ts

@@ -1,17 +1,22 @@
-import { curveOf, CURVE_TYPES, curveSpace, sampleCurve, type CurveType } from "../curves/index.ts";
+import { CURVE_TYPES, curveSpace, sampleCurve, type CurveType } from "../curves/index.ts";
 import { polylineLength } from "../geom.ts";
 import { nodeIndex, type Graph, type Router } from "../model.ts";
 import { nearestSide, SIDE_NORMAL } from "../plugs.ts";
+import { curveStrategies } from "../strategies/builtins.ts";
+import type { Strategy } from "../strategies/model.ts";
 import { measureLinks, type MeasuredLink } from "./links.ts";
 
 // The core runs in any host, so it reads the clock without the types of Node or the browser.
 const now = (): number => (globalThis as { performance?: { now(): number } }).performance?.now() ?? Date.now();
 
-/** One row of the benchmark of the curves: one curve type on the routes of one router on one fixture. */
-export interface CurveBenchRow {
+/**
+ * One row of the benchmark of the curves: one curve type on the routes of one router on one fixture.
+ * The type `T` of the name of the curve is `CurveType` for `benchCurves`, and `string` for `benchCurveStrategies`.
+ */
+export interface CurveBenchRow<T extends string = CurveType> {
   readonly router: string;
   readonly fixture: string;
-  readonly type: CurveType;
+  readonly type: T;
   /** The number of routes. */
   readonly links: number;
   /** The number of polylines that go through a box that is not one of their ends (`measureLinks`). */
@@ -40,6 +45,27 @@ export interface CurveBenchOptions {
  * The type `spline` leaves each plug along the normal of the nearest side of its node.
  */
 export function benchCurves(router: Router, fixture: string, graph: Graph, options: CurveBenchOptions = {}): CurveBenchRow[] {
+  // Each built-in curve strategy has the name of its curve type, so each row has a `CurveType`.
+  return benchCurveStrategies(
+    router,
+    fixture,
+    graph,
+    CURVE_TYPES.map((t) => curveStrategies[t]),
+    options,
+  ) as CurveBenchRow[];
+}
+
+/**
+ * This function does the work of `benchCurves` with a list of curve strategies, in place of the curve types.
+ * The option `radius` goes to each strategy. A strategy without such an option does not read it.
+ */
+export function benchCurveStrategies(
+  router: Router,
+  fixture: string,
+  graph: Graph,
+  curves: readonly Strategy<"curve">[],
+  options: CurveBenchOptions = {},
+): CurveBenchRow<string>[] {
   const tolerance = options.tolerance ?? 0.25;
   const result = router.route(graph);
   const byId = nodeIndex(graph);
@@ -60,13 +86,14 @@ export function benchCurves(router: Router, fixture: string, graph: Graph, optio
   });
   const base = measureLinks(boxes, routes);
   const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
-  return CURVE_TYPES.map((type): CurveBenchRow => {
+  const radius = { radius: options.radius ?? 12 };
+  return curves.map((curve): CurveBenchRow<string> => {
     const make = (withSpace: boolean): MeasuredLink[] =>
       routes.map((r) => ({
         source: r.source,
         target: r.target,
         points: sampleCurve(
-          curveOf(r.points, { type, radius: options.radius ?? 12, startNormal: r.startNormal, endNormal: r.endNormal, ...(withSpace ? { space } : {}) }),
+          curve.run({ points: r.points, startNormal: r.startNormal, endNormal: r.endNormal, ...(withSpace ? { space } : {}) }, radius),
           tolerance,
         ),
       }));
@@ -78,7 +105,7 @@ export function benchCurves(router: Router, fixture: string, graph: Graph, optio
     return {
       router: router.name,
       fixture,
-      type,
+      type: curve.name,
       links: routes.length,
       through: base.through,
       free: free.through,
@@ -90,7 +117,7 @@ export function benchCurves(router: Router, fixture: string, graph: Graph, optio
 }
 
 /** This function writes the rows of `benchCurves` as a Markdown table. */
-export function formatCurves(rows: readonly CurveBenchRow[]): string {
+export function formatCurves(rows: readonly CurveBenchRow<string>[]): string {
   const head = "| router | fixture | curve | routes | through, polyline | through, free | through, clamped | length | ms |";
   const line = "|---|---|---|---:|---:|---:|---:|---:|---:|";
   const body = rows.map((r) => `| ${r.router} | ${r.fixture} | ${r.type} | ${r.links} | ${r.through} | ${r.free} | ${r.clamped} | ${r.length.toFixed(3)} | ${r.ms.toFixed(1)} |`);

package/src/bench/room.ts

@@ -1,8 +1,11 @@
 import { levelLinks } from "../levels.ts";
 import type { Graph, Node, Result } from "../model.ts";
-import { makeRoom, roomLinks, type RoomOptions } from "../room/index.ts";
+import { makeRoom, openGaps, roomLinks, type RoomOptions } from "../room/index.ts";
+import { gapLanes, LANE_ORDERS, type LaneOrder } from "../room/lanes.ts";
 import { sectionsRouter } from "../routers/sections.ts";
 import { laneRoutes, runKey, segmentsOf } from "../segments.ts";
+import { roomStrategies } from "../strategies/builtins.ts";
+import type { Strategy } from "../strategies/model.ts";
 import { measureLinks, measureRouteFaults, type LinkFaults } from "./links.ts";
 import { measureQuality } from "./quality.ts";
 
@@ -50,15 +53,18 @@ function areaOf(nodes: readonly Node[]): number {
 
 /**
  * This function measures the links of one board. It measures the links of the far view, with each node of the graph as one item of a level.
- * It also measures the lane routes of the router `sections` at the lane width `spacing`.
+ * With a lane order, each link of the far view gets its own lane in each gap (`gapLanes` at the lane width `spacing`).
+ * Without it, the links of a gap share the lines of the level links.
+ * The function also measures the lane routes of the router `sections` at the lane width `spacing`.
  */
-export function measureBoard(graph: Graph, spacing: number): Omit<RoomBenchRow, "fixture" | "board" | "area" | "ms"> {
+export function measureBoard(graph: Graph, spacing: number, order?: LaneOrder): Omit<RoomBenchRow, "fixture" | "board" | "area" | "ms"> {
   const links = roomLinks(graph);
   const items = graph.nodes.map((n) => ({ id: n.id, box: n.box, nodes: [n.id] }));
-  const drawn = levelLinks(
+  const level = levelLinks(
     items,
     links.map((l) => ({ source: l.source, target: l.target, count: l.count ?? 1 })),
   );
+  const drawn = order ? gapLanes(graph.nodes, level, { spacing, order }) : level;
   const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
   // `measureQuality` reads routes of edges, so each link of the far view stands for the first edge of its pair.
   const edgeOf = new Map<string, string>();
@@ -82,10 +88,15 @@ export function measureBoard(graph: Graph, spacing: number): Omit<RoomBenchRow,
 }
 
 /**
- * This function measures a packed board, the board with each gap open to the gutter only, and the board that `makeRoom` opens with each method.
- * The options of `makeRoom` are the same for each method, except `method`.
+ * This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
+ * The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
  */
-export function benchRoom(fixture: string, graph: Graph, options: RoomOptions = {}): RoomBenchRow[] {
+export function benchRoom(
+  fixture: string,
+  graph: Graph,
+  options: RoomOptions = {},
+  methods: readonly Strategy<"room">[] = [roomStrategies.routes, roomStrategies.lines],
+): RoomBenchRow[] {
   const spacing = options.spacing ?? 4;
   const area0 = areaOf(graph.nodes);
   const links = roomLinks(graph);
@@ -97,19 +108,76 @@ export function benchRoom(fixture: string, graph: Graph, options: RoomOptions =
     ...measureBoard({ nodes, edges: graph.edges }, spacing),
   });
   const rows = [row("packed", graph.nodes, 0)];
-  const states: [string, RoomOptions][] = [
-    ["gutter", { ...options, spacing: 0, method: "routes" }],
-    ["routes", { ...options, method: "routes" }],
-    ["lines", { ...options, method: "lines" }],
-  ];
-  for (const [board, o] of states) {
+  const t0 = now();
+  const gutter = makeRoom(graph.nodes, links, { ...options, spacing: 0, method: "routes" });
+  rows.push(row("gutter", gutter.items, now() - t0));
+  const { method: _method, ...preset } = options;
+  for (const s of methods) {
+    const t1 = now();
+    const gaps = s.run({ items: graph.nodes, links }, preset);
+    const nodes = openGaps(graph.nodes, gaps, options.snap);
+    rows.push(row(s.name, nodes, now() - t1));
+  }
+  return rows;
+}
+
+/** One setting of a sweep of the room: the options of `makeRoom` and the lane order of the far view. */
+export interface RoomSetting {
+  /** The name of the setting in the column `board`. */
+  readonly name: string;
+  readonly options: RoomOptions;
+  /** The lane order of the far view. Without it, the links of a gap share the lines of the level links. */
+  readonly lanes?: LaneOrder;
+}
+
+/**
+ * This function measures the board that `makeRoom` opens with each setting, with the method `routes`.
+ * The first row is the fair baseline: the board with each gap open to the gutter of `baseline` only, measured at the spacing of `baseline`.
+ */
+export function sweepRoom(fixture: string, graph: Graph, settings: readonly RoomSetting[], baseline: RoomOptions = { gutter: 8, spacing: 4 }): RoomBenchRow[] {
+  const area0 = areaOf(graph.nodes);
+  const links = roomLinks(graph);
+  const row = (board: string, nodes: readonly Node[], ms: number, spacing: number, lanes?: LaneOrder): RoomBenchRow => ({
+    fixture,
+    board,
+    area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+    ms,
+    ...measureBoard({ nodes, edges: graph.edges }, spacing, lanes),
+  });
+  const fair = makeRoom(graph.nodes, links, { ...baseline, spacing: 0, method: "routes", maxGrowth: Infinity, passes: 1 });
+  const rows = [row("gutter", fair.items, 0, baseline.spacing ?? 4)];
+  for (const s of settings) {
     const t0 = now();
-    const room = makeRoom(graph.nodes, links, o);
-    rows.push(row(board, room.items, now() - t0));
+    const open = makeRoom(graph.nodes, links, { ...s.options, method: "routes" });
+    rows.push(row(s.name, open.items, now() - t0, s.options.spacing ?? 4, s.lanes));
   }
   return rows;
 }
 
+/** The values of `maxGrowth` of the sweep of ROOM-A. */
+export const GROWTH_SWEEP: readonly number[] = [0, 0.06, 0.09, 0.12, 0.15, 0.18, 0.21, 0.25, 0.3, 0.35, 0.5, Infinity];
+
+/** This function gives the settings of ROOM-A: the area and the faults for each `maxGrowth`, at gutter 8 and spacing 4. */
+export function growthSettings(values: readonly number[] = GROWTH_SWEEP): RoomSetting[] {
+  return values.map((m) => ({ name: `maxGrowth ${m}`, options: { gutter: 8, spacing: 4, maxGrowth: m } }));
+}
+
+/**
+ * This function gives the settings of ROOM-C: each lane order of the far view at each spacing, at gutter 8.
+ * The order `shared` is the far view without lanes, as before ROOM-C.
+ */
+export function laneSettings(spacings: readonly number[] = [2, 4, 6, 8], orders: readonly LaneOrder[] = LANE_ORDERS): RoomSetting[] {
+  return spacings.flatMap((spacing) => [
+    { name: `shared spacing ${spacing}`, options: { gutter: 8, spacing } },
+    ...orders.map((lanes) => ({ name: `${lanes} spacing ${spacing}`, options: { gutter: 8, spacing }, lanes })),
+  ]);
+}
+
+/** This function gives the settings of ROOM-D: each gutter with each number of passes, at spacing 4. */
+export function passSettings(gutters: readonly number[] = [4, 8, 12, 16], passes: readonly number[] = [1, 2]): RoomSetting[] {
+  return gutters.flatMap((gutter) => passes.map((p) => ({ name: `gutter ${gutter} passes ${p}`, options: { gutter, spacing: 4, passes: p } })));
+}
+
 /** This function writes the rows of `benchRoom` as a Markdown table. */
 export function formatRoom(rows: readonly RoomBenchRow[]): string {
   const head = "| fixture | board | area | links | through | outside | out and back | worst detour | crossings | ink | detour | lane through | ms |";

package/src/index.ts

@@ -12,9 +12,11 @@ export * from "./segments.ts";
 export * from "./sections.ts";
 export * from "./routers/index.ts";
 export * from "./room/index.ts";
+export * from "./room/lanes.ts";
 export * from "./bench/properties.ts";
 export * from "./bench/quality.ts";
 export * from "./bench/links.ts";
 export * from "./bench/run.ts";
 export * from "./bench/curves.ts";
 export * from "./bench/room.ts";
+export * from "./strategies/index.ts";

package/src/room/index.ts

@@ -64,6 +64,12 @@ export interface RoomOptions {
   readonly lanes?: "link" | "count";
   /** Two box edges nearer than this distance make one boundary of the sweep. The default is 0.5. */
   readonly snap?: number;
+  /**
+   * The number of passes of the demand. The default is 1.
+   * Each pass after the first finds the lanes again on the board that the passes before it opened, and adds the growth that it needs.
+   * The limit `maxGrowth` applies to the sum of the passes.
+   */
+  readonly passes?: number;
 }
 
 /** The demand of a board and the board with its gaps open. */
@@ -147,14 +153,28 @@ export function openGaps<T extends Boxed>(items: readonly T[], gaps: readonly Ga
  * The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
  */
 export function roomDemand(items: readonly Boxed[], links: readonly RoomLink[], options: RoomOptions = {}): Gap[] {
+  const gutter = options.gutter ?? DEFAULT_GUTTER;
+  const snap = options.snap ?? DEFAULT_SNAP;
+  const passes = Math.max(1, Math.floor(options.passes ?? 1));
+  let total = demandOnce(items, links, options);
+  for (let p = 1; p < passes; p++) {
+    // The next pass measures the board that the passes before it opened. Its gaps are the same gaps, in the same order.
+    const next = demandOnce(openGaps(items, total, snap), links, options);
+    if (next.length !== total.length || next.some((g, i) => g.axis !== total[i]!.axis)) break;
+    total = total.map((g, i) => ({ ...g, lanes: Math.max(g.lanes, next[i]!.lanes), need: g.need + Math.max(0, next[i]!.need - next[i]!.width) }));
+  }
+  return capGrowth(items, total, gutter, options.maxGrowth ?? Infinity);
+}
+
+/** This function gives the demand of one pass, without the limit `maxGrowth`. */
+function demandOnce(items: readonly Boxed[], links: readonly RoomLink[], options: RoomOptions): Gap[] {
   const gutter = options.gutter ?? DEFAULT_GUTTER;
   const spacing = options.spacing ?? DEFAULT_SPACING;
   const snap = options.snap ?? DEFAULT_SNAP;
   const weight = (l: RoomLink): number => (options.lanes === "count" ? Math.max(1, l.count ?? 1) : 1);
   const gaps = boardGaps(items, snap);
   const lanes = (options.method ?? "routes") === "lines" ? lineLanes(items, links, gaps, weight) : routeLanes(items, links, gaps, gutter, snap, weight, options.router);
-  const raw = gaps.map((g, i) => ({ ...g, lanes: lanes[i]!, need: Math.max(g.width, gutter + lanes[i]! * spacing) }));
-  return capGrowth(items, raw, gutter, options.maxGrowth ?? Infinity);
+  return gaps.map((g, i) => ({ ...g, lanes: lanes[i]!, need: Math.max(g.width, gutter + lanes[i]! * spacing) }));
 }
 
 /** This function gives the demand of the board and the board with each gap open to its need. */

package/src/room/lanes.ts

@@ -0,0 +1,175 @@
+import { segmentHitsBox, type Box, type Point } from "../geom.ts";
+import { Grid } from "../grid.ts";
+import type { LevelLink } from "../model.ts";
+import { boardGaps, type Boxed } from "./index.ts";
+
+/**
+ * The lane order of the pieces of the links in one gap.
+ *
+ * - `links`: the order of the list of links. This order reads nothing of the board.
+ * - `ends`: the pieces that turn to the near side at their two ends come first. The pieces that turn to the far side come last.
+ * - `crossings`: the order with the fewest crossings between the pieces of the gap and the legs at their ends. A local search finds it.
+ */
+export type LaneOrder = "links" | "ends" | "crossings";
+
+/** The lane orders of `gapLanes`, in the order of the benchmark. */
+export const LANE_ORDERS: readonly LaneOrder[] = ["links", "ends", "crossings"];
+
+/** The options of `gapLanes`. */
+export interface GapLaneOptions {
+  /** The largest distance between two lanes. A narrow gap puts its lanes nearer. The default is 4. */
+  readonly spacing?: number;
+  /** The lane order in each gap. The default is `crossings`. */
+  readonly order?: LaneOrder;
+  /** Two box edges nearer than this distance make one boundary of the sweep, as in `boardGaps`. The default is 0.5. */
+  readonly snap?: number;
+}
+
+/** A piece of a link: a leg of the link that runs along a gap. */
+interface Piece {
+  /** The index of the link. */
+  readonly link: number;
+  /** The index of the last point of the leg. The leg goes from the point `seg - 1` to the point `seg`. */
+  readonly seg: number;
+  /** The span of the leg along the gap. */
+  readonly lo: number;
+  readonly hi: number;
+  /** For each end of the leg: its place along the gap, and the side (-1 or 1) across the gap where the link turns. */
+  readonly turns: readonly (readonly [number, number])[];
+}
+
+const EPS = 1e-6;
+const ROUNDS = 8;
+
+/**
+ * This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
+ * A leg of a link moves across its gap only, so the link keeps its plugs and the axes of its legs.
+ * When a move puts a link through more boxes than before, the link keeps its points.
+ */
+export function gapLanes(items: readonly Boxed[], links: readonly LevelLink[], options: GapLaneOptions = {}): LevelLink[] {
+  const spacing = Math.max(0, options.spacing ?? 4);
+  const order = options.order ?? "crossings";
+  const moved = links.map((l) => l.points.map((p) => ({ x: p.x, y: p.y })));
+  for (const g of boardGaps(items, options.snap)) {
+    if (g.width <= EPS) continue;
+    const across = g.axis;
+    const along = g.axis === "x" ? "y" : "x";
+    const lo = g.at - g.width;
+    const hi = g.at;
+    const pieces: Piece[] = [];
+    links.forEach((l, li) => {
+      const p = l.points;
+      // The first and the last legs hold the plugs, so they do not move.
+      for (let i = 2; i <= p.length - 2; i++) {
+        const a = p[i - 1]!;
+        const b = p[i]!;
+        if (Math.abs(a[across] - b[across]) > EPS || a[across] <= lo + EPS || a[across] >= hi - EPS) continue;
+        if (Math.abs(a[along] - b[along]) <= EPS) continue;
+        const side = (q: Point, r: Point): number => Math.sign(r[across] - q[across]);
+        pieces.push({
+          link: li,
+          seg: i,
+          lo: Math.min(a[along], b[along]),
+          hi: Math.max(a[along], b[along]),
+          turns: [
+            [a[along], side(a, p[i - 2]!)],
+            [b[along], side(b, p[i + 1]!)],
+          ],
+        });
+      }
+    });
+    if (pieces.length === 0) continue;
+    const list = orderPieces(pieces, order);
+    // A piece goes one lane past each piece before it in the order that it overlaps. Thus two pieces that overlap keep their order.
+    const lane: number[] = [];
+    let n = 0;
+    list.forEach((P, i) => {
+      let k = 0;
+      for (let j = 0; j < i; j++) if (overlaps(list[j]!, P)) k = Math.max(k, lane[j]! + 1);
+      lane.push(k);
+      n = Math.max(n, k + 1);
+    });
+    const step = Math.min(spacing, g.width / (n + 1));
+    const mid = (lo + hi) / 2;
+    list.forEach((P, i) => {
+      const v = mid + (lane[i]! - (n - 1) / 2) * step;
+      moved[P.link]![P.seg - 1]![across] = v;
+      moved[P.link]![P.seg]![across] = v;
+    });
+  }
+  const boxes = new Grid<Box>(Math.max(20, meanSide(items)));
+  for (const i of items) boxes.add(i.box, i.box);
+  return links.map((l, i) => (hits(boxes, moved[i]!) > hits(boxes, l.points) ? l : { ...l, points: moved[i]! }));
+}
+
+const overlaps = (P: Piece, Q: Piece): boolean => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS;
+
+/**
+ * This function counts the crossings when the piece `P` is on the near side of the piece `Q`.
+ * A turn of `P` to the far side crosses `Q` when it is inside the span of `Q`. A turn of `Q` to the near side crosses `P` in the same way.
+ */
+function cost(P: Piece, Q: Piece): number {
+  let c = 0;
+  for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS && y < Q.hi - EPS) c++;
+  for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS && y < P.hi - EPS) c++;
+  return c;
+}
+
+/** This function gives the pieces of one gap in lane order, from the near side to the far side. */
+function orderPieces(pieces: readonly Piece[], order: LaneOrder): Piece[] {
+  if (order === "links") return [...pieces];
+  const sum = (P: Piece): number => P.turns.reduce((s, [, side]) => s + side, 0);
+  const list = [...pieces].sort((P, Q) => sum(P) - sum(Q) || P.link - Q.link || P.seg - Q.seg);
+  if (order === "ends") return list;
+  // The local search moves one piece to the place that removes the most crossings, until no move removes one.
+  const n = list.length;
+  const index = new Map(list.map((P, i) => [P, i]));
+  const c: number[][] = list.map((P) => list.map((Q) => (P !== Q && overlaps(P, Q) ? cost(P, Q) : 0)));
+  const at = (P: Piece, Q: Piece): number => c[index.get(P)!]![index.get(Q)!]!;
+  for (let round = 0; round < ROUNDS; round++) {
+    let better = false;
+    for (let i = 0; i < n; i++) {
+      const x = list[i]!;
+      // The change of the crossings when `x` moves to the place `k`, for each `k`.
+      let best = 0;
+      let to = i;
+      let d = 0;
+      for (let k = i - 1; k >= 0; k--) {
+        d += at(x, list[k]!) - at(list[k]!, x);
+        if (d < best) [best, to] = [d, k];
+      }
+      d = 0;
+      for (let k = i + 1; k < n; k++) {
+        d += at(list[k]!, x) - at(x, list[k]!);
+        if (d < best) [best, to] = [d, k];
+      }
+      if (to !== i) {
+        list.splice(i, 1);
+        list.splice(to, 0, x);
+        better = true;
+      }
+    }
+    if (!better) break;
+  }
+  return list;
+}
+
+/** This function gives the mean of the longer side of the boxes. */
+function meanSide(items: readonly Boxed[]): number {
+  let s = 0;
+  for (const i of items) s += Math.max(i.box.w, i.box.h);
+  return items.length ? s / items.length : 1;
+}
+
+/** This function counts the legs of a polyline that go through a box, for each box. */
+function hits(boxes: Grid<Box>, p: readonly Point[]): number {
+  let n = 0;
+  for (let i = 1; i < p.length; i++) {
+    const a = p[i - 1]!;
+    const b = p[i]!;
+    boxes.querySegment(a, b, 0, (box) => {
+      if (segmentHitsBox(a, b, box)) n++;
+    });
+  }
+  return n;
+}

package/src/routers/index.ts

@@ -13,7 +13,7 @@ export { sharedRouter, type SharedOptions } from "./shared.ts";
 export { sectionsRouter, type SectionsOptions } from "./sections.ts";
 export { byCollection, groupEdges, laneOrder, splitPoint, trunksRouter, type TrunksOptions } from "./trunks.ts";
 
-/** The routers that the benchmark races. */
+/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
 export const ROUTERS: readonly Router[] = [
   straightRouter,
   plugsRouter,

package/src/strategies/builtins.ts

@@ -0,0 +1,169 @@
+import { arcCurve, type ArcOptions } from "../curves/arc/index.ts";
+import { roundedCurve, type RoundedOptions } from "../curves/rounded/index.ts";
+import { splineCurve, type SplineOptions } from "../curves/spline/index.ts";
+import { straightCurve } from "../curves/straight/index.ts";
+import type { Graph, Result, Router } from "../model.ts";
+import { roomDemand, type RoomMethod, type RoomOptions } from "../room/index.ts";
+import { cornersRouter, type CornersOptions } from "../routers/corners.ts";
+import { plugsRouter } from "../routers/plugs.ts";
+import { sectionsRouter, type SectionsOptions } from "../routers/sections.ts";
+import { sharedRouter, type SharedOptions } from "../routers/shared.ts";
+import { straightRouter } from "../routers/straight.ts";
+import { byCollection, trunksRouter, type TrunksOptions } from "../routers/trunks.ts";
+import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type Registry, type Strategy } from "./model.ts";
+
+/** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
+export type RouterPreset<O> = Omit<O, "name" | "maxNodes">;
+
+/** This function makes a router strategy from a router factory and a preset of its options. Each call makes the router of its options. */
+function routerStrategy<O extends object>(
+  name: string,
+  describe: string,
+  maxNodes: number,
+  defaults: O,
+  make: (options: O & { readonly name: string }) => Router,
+): Strategy<"router", O> {
+  return defineStrategy({ step: "router", name, describe, defaults, maxNodes, run: (graph: Graph, options: Readonly<O>): Result => make({ ...options, name }).route(graph) });
+}
+
+/** This function makes a router strategy for a router without options. */
+function fixedRouter(router: Router, describe: string): Strategy<"router", object> {
+  return defineStrategy({ step: "router", name: router.name, describe, defaults: {}, run: (graph: Graph): Result => router.route(graph) });
+}
+
+/** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
+export const routerStrategies: {
+  readonly straight: Strategy<"router", object>;
+  readonly plugs: Strategy<"router", object>;
+  readonly corners: Strategy<"router", RouterPreset<CornersOptions>>;
+  readonly "corners-smooth": Strategy<"router", RouterPreset<CornersOptions>>;
+  readonly trunks: Strategy<"router", RouterPreset<TrunksOptions>>;
+  readonly shared: Strategy<"router", RouterPreset<SharedOptions>>;
+  readonly "shared-all": Strategy<"router", RouterPreset<SharedOptions>>;
+  readonly sections: Strategy<"router", RouterPreset<SectionsOptions>>;
+  readonly "sections-tree": Strategy<"router", RouterPreset<SectionsOptions>>;
+} = Object.freeze({
+  straight: fixedRouter(straightRouter, "The control. Each edge is one straight line between its plugs."),
+  plugs: fixedRouter(
+    plugsRouter,
+    "Each edge leaves its plug along the normal of the side and follows the curve of the inflection rule. It does not go around the nodes.",
+  ),
+  corners: routerStrategy<RouterPreset<CornersOptions>>(
+    "corners",
+    "Each edge goes around the nodes on a shortest path (A*) through a sparse visibility graph of the box corners.",
+    10_000,
+    {},
+    cornersRouter,
+  ),
+  "corners-smooth": routerStrategy<RouterPreset<CornersOptions>>(
+    "corners-smooth",
+    "The same paths as `corners`. A route in clear view follows the inflection rule, and the other routes get round corners.",
+    10_000,
+    { smooth: true },
+    cornersRouter,
+  ),
+  trunks: routerStrategy<RouterPreset<TrunksOptions>>(
+    "trunks",
+    "A rule puts edges in groups. The edges of a group leave one plug of one node on one trunk. At a split point, each edge goes on to its target.",
+    10_000,
+    { rule: byCollection },
+    trunksRouter,
+  ),
+  shared: routerStrategy<RouterPreset<SharedOptions>>(
+    "shared",
+    "The edges of one collection share their ways through the corner graph. A link that the group uses already costs half.",
+    10_000,
+    { rule: byCollection },
+    sharedRouter,
+  ),
+  "shared-all": routerStrategy<RouterPreset<SharedOptions>>("shared-all", "The same as `shared`, but all edges share their ways.", 10_000, {}, sharedRouter),
+  sections: routerStrategy<RouterPreset<SectionsOptions>>(
+    "sections",
+    "A tree of sections, with a hub in each section. A long edge goes through the hubs, and a short edge goes directly.",
+    100_000,
+    {},
+    sectionsRouter,
+  ),
+  "sections-tree": routerStrategy<RouterPreset<SectionsOptions>>(
+    "sections-tree",
+    "The same as `sections`, but without the limit of the stretch.",
+    100_000,
+    { stretch: Infinity },
+    sectionsRouter,
+  ),
+});
+
+/** The context of a curve input, without the keys that have no value. */
+const contextOf = (input: CurveInput): Omit<CurveInput, "points"> => ({
+  ...(input.startNormal ? { startNormal: input.startNormal } : {}),
+  ...(input.endNormal ? { endNormal: input.endNormal } : {}),
+  ...(input.space ? { space: input.space } : {}),
+});
+
+/** The options of the curve strategies `rounded` and `arc`. */
+export interface RadiusOptions {
+  /** The radius of the corners. The default is 12. */
+  readonly radius: number;
+}
+
+/** The options of the curve strategy `spline`. */
+export interface TensionOptions {
+  /** The tension of the spline, from 0 (the spline) to 1 (the polyline). The default is 0. */
+  readonly tension: number;
+}
+
+/** The built-in curve strategies, in the order of `CURVE_TYPES`. Each one gives the same segments as `curveOf` with its type. */
+export const curveStrategies: {
+  readonly straight: Strategy<"curve", object>;
+  readonly rounded: Strategy<"curve", RadiusOptions>;
+  readonly spline: Strategy<"curve", TensionOptions>;
+  readonly arc: Strategy<"curve", RadiusOptions>;
+} = Object.freeze({
+  straight: defineStrategy({ step: "curve", name: "straight", describe: "The polyline as it is.", defaults: {}, run: (input: CurveInput) => straightCurve(input.points) }),
+  rounded: defineStrategy({
+    step: "curve",
+    name: "rounded",
+    describe: "A quadratic Bezier curve at each corner, as `roundCorners` draws it. The first and the last legs stay.",
+    defaults: { radius: 12 },
+    run: (input: CurveInput, o: Readonly<RadiusOptions>) => roundedCurve(input.points, { ...contextOf(input), radius: o.radius } satisfies RoundedOptions),
+  }),
+  spline: defineStrategy({
+    step: "curve",
+    name: "spline",
+    describe: "A centripetal Catmull-Rom spline through each point. It does not overshoot or make loops in a piece.",
+    defaults: { tension: 0 },
+    run: (input: CurveInput, o: Readonly<TensionOptions>) => splineCurve(input.points, { ...contextOf(input), tension: o.tension } satisfies SplineOptions),
+  }),
+  arc: defineStrategy({
+    step: "curve",
+    name: "arc",
+    describe: "A circular arc at each corner, tangent to the two legs. The first and the last legs stay.",
+    defaults: { radius: 12 },
+    run: (input: CurveInput, o: Readonly<RadiusOptions>) => arcCurve(input.points, { ...contextOf(input), radius: o.radius } satisfies ArcOptions),
+  }),
+});
+
+/** The options of a room strategy: the options of `roomDemand`, without the method. */
+export type RoomPreset = Omit<RoomOptions, "method">;
+
+const roomStrategy = (method: RoomMethod, describe: string): Strategy<"room", RoomPreset> =>
+  defineStrategy<"room", RoomPreset>({ step: "room", name: method, describe, defaults: {}, run: (input, o) => roomDemand(input.items, input.links, { ...o, method }) });
+
+/** The built-in room strategies: the methods of `roomDemand`. */
+export const roomStrategies: {
+  readonly routes: Strategy<"room", RoomPreset>;
+  readonly lines: Strategy<"room", RoomPreset>;
+} = Object.freeze({
+  routes: roomStrategy("routes", "The lanes of a gap are the most routes that run along it side by side, with each gap open to the gutter."),
+  lines: roomStrategy("lines", "The lanes of a gap are the straight lines between the centers of the boxes that cross the gap."),
+});
+
+/** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
+export const BUILT_IN_STRATEGIES: readonly AnyStrategy[] = Object.freeze([
+  ...Object.values(routerStrategies),
+  ...Object.values(curveStrategies),
+  ...Object.values(roomStrategies),
+]);
+
+/** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
+export const STRATEGIES: Registry = createRegistry(BUILT_IN_STRATEGIES);

package/src/strategies/index.ts

@@ -0,0 +1,2 @@
+export * from "./model.ts";
+export * from "./builtins.ts";