@mark1russell7/highways 0.1.3 → 0.1.5

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";

package/src/strategies/model.ts

@@ -0,0 +1,157 @@
+import type { CurveSegment } from "../curves/model.ts";
+import type { CurveSpace } from "../curves/space.ts";
+import type { Point } from "../geom.ts";
+import type { Graph, Result, Router } from "../model.ts";
+import type { Boxed, Gap, RoomLink } from "../room/index.ts";
+
+/** The input of a curve strategy: one polyline and the context of its route. */
+export interface CurveInput {
+  /** These points are the polyline: a route of a router, a lane of `laneRoutes` or a link of a zoom level. */
+  readonly points: readonly Point[];
+  /** The curve leaves the first point along this outward normal of its plug, if the strategy reads it. */
+  readonly startNormal?: Point;
+  /** The curve comes into the last point against this outward normal of its plug, if the strategy reads it. */
+  readonly endNormal?: Point;
+  /** The boxes that the curve must not go through, from `curveSpace`. */
+  readonly space?: CurveSpace;
+}
+
+/** The input of a room strategy: the boxes of a board and the links between them. */
+export interface RoomInput {
+  readonly items: readonly Boxed[];
+  readonly links: readonly RoomLink[];
+}
+
+/**
+ * The steps that have strategies, with the fixed input and output type of each step.
+ *
+ * - `router`: a graph in, the routes (and the `levels`, `bundles` and `runs`) out.
+ * - `curve`: a polyline in, the segments of a curve out.
+ * - `room`: the boxes and links of a board in, the gaps of the board with their need out.
+ */
+export interface StepTypes {
+  readonly router: { readonly input: Graph; readonly output: Result };
+  readonly curve: { readonly input: CurveInput; readonly output: CurveSegment[] };
+  readonly room: { readonly input: RoomInput; readonly output: Gap[] };
+}
+
+/** The name of a step that has strategies. */
+export type Step = keyof StepTypes;
+
+/** The input type of a step. */
+export type StepInput<S extends Step> = StepTypes[S]["input"];
+
+/** The output type of a step. */
+export type StepOutput<S extends Step> = StepTypes[S]["output"];
+
+/** The steps that have strategies, in the order of the pipeline. */
+export const STEPS: readonly Step[] = ["router", "curve", "room"];
+
+/**
+ * A strategy: one way to do one step, with a name and a description.
+ * The same input and the same options must give the same output.
+ */
+export interface Strategy<S extends Step = Step, O extends object = object> {
+  /** The step of the strategy. It fixes the input and the output type. */
+  readonly step: S;
+  /** The name of the strategy. Each name is unique in its step of a registry. */
+  readonly name: string;
+  /** One or two sentences that tell what the strategy does. The site and the documents show them. */
+  readonly describe: string;
+  /** The values of the options when the caller gives no value. */
+  readonly defaults: Readonly<O>;
+  /** The benchmark skips an input with more nodes than this. Without it, the strategy takes each input. */
+  readonly maxNodes?: number;
+  /** This method does the step. Each option that `options` does not give gets its value from `defaults`. */
+  run(input: StepInput<S>, options?: Partial<O>): StepOutput<S>;
+}
+
+/** A strategy of any step. A registry holds a list of these. */
+export type AnyStrategy = { [S in Step]: Strategy<S> }[Step];
+
+/** The definition of a strategy, for `defineStrategy`. */
+export interface StrategyDefinition<S extends Step, O extends object> {
+  readonly step: S;
+  readonly name: string;
+  readonly describe: string;
+  /** These values are the options when the caller gives no value. Give `{}` for a strategy without options. */
+  readonly defaults: O;
+  readonly maxNodes?: number;
+  /** This function does the step. It gets each option, from the caller or from `defaults`. */
+  run(input: StepInput<S>, options: Readonly<O>): StepOutput<S>;
+}
+
+/**
+ * This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
+ * When the caller gives no option, the definition gets the `defaults` object itself.
+ */
+export function defineStrategy<S extends Step, O extends object>(definition: StrategyDefinition<S, O>): Strategy<S, O> {
+  const { step, name, describe, defaults, maxNodes } = definition;
+  if (name.length === 0) throw new Error(`A strategy of the step "${step}" has no name.`);
+  const strategy: Strategy<S, O> = {
+    step,
+    name,
+    describe,
+    defaults: Object.freeze({ ...defaults }),
+    ...(maxNodes === undefined ? {} : { maxNodes }),
+    run(input: StepInput<S>, options?: Partial<O>): StepOutput<S> {
+      const all = options === undefined || Object.keys(options).length === 0 ? strategy.defaults : { ...strategy.defaults, ...options };
+      return definition.run(input, all as Readonly<O>);
+    },
+  };
+  return Object.freeze(strategy);
+}
+
+/**
+ * A registry: the strategies of each step, in order. A registry is data. No import changes it.
+ * A consumer makes its own registry with `createRegistry`, and adds a strategy with `register`.
+ */
+export type Registry = { readonly [S in Step]: readonly Strategy<S>[] };
+
+/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
+export function createRegistry(strategies: readonly AnyStrategy[]): Registry {
+  const out: { [S in Step]: Strategy<S>[] } = { router: [], curve: [], room: [] };
+  for (const s of strategies) {
+    const list = out[s.step] as AnyStrategy[] | undefined;
+    if (!list) throw new Error(`There is no step "${String(s.step)}". The steps are ${STEPS.join(", ")}.`);
+    if (list.some((t) => t.name === s.name)) throw new Error(`The step "${s.step}" has two strategies with the name "${s.name}".`);
+    list.push(s);
+  }
+  return Object.freeze({ router: Object.freeze(out.router), curve: Object.freeze(out.curve), room: Object.freeze(out.room) });
+}
+
+/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
+export function register(registry: Registry, ...strategies: readonly AnyStrategy[]): Registry {
+  return createRegistry([...registry.router, ...registry.curve, ...registry.room, ...strategies]);
+}
+
+/** This function gives the strategies of one step of a registry, in order. */
+export function listStrategies<S extends Step>(registry: Registry, step: S): readonly Strategy<S>[] {
+  return registry[step];
+}
+
+/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
+export function findStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S> | undefined {
+  return listStrategies(registry, step).find((s) => s.name === name);
+}
+
+/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
+export function getStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S> {
+  const s = findStrategy(registry, step, name);
+  if (!s) throw new Error(`There is no ${step} "${name}". The registry has ${listStrategies(registry, step).map((t) => t.name).join(", ")}.`);
+  return s;
+}
+
+/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
+export function asRouter<O extends object>(strategy: Strategy<"router", O>, options?: Partial<O>): Router {
+  return {
+    name: strategy.name,
+    ...(strategy.maxNodes === undefined ? {} : { maxNodes: strategy.maxNodes }),
+    route: (graph: Graph): Result => strategy.run(graph, options),
+  };
+}
+
+/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
+export function routersOf(registry: Registry): Router[] {
+  return listStrategies(registry, "router").map((s) => asRouter(s));
+}

package/src/visibility.ts

@@ -86,6 +86,11 @@ export interface CornerGraphOptions {
    * The lattice links groups of nodes across empty space. Without it, the nearest corners of a group are all in that group.
    */
   readonly lattice?: number;
+  /**
+   * With `cones`, each corner also links to the nearest corner that it can see in each of four cones around the axes.
+   * Then a path can go along a long corridor between rows or columns of boxes. The default is false.
+   */
+  readonly cones?: boolean;
 }
 
 /**
@@ -164,7 +169,8 @@ export class CornerGraph {
     }
     const links: Set<number>[] = this.points.map(() => new Set<number>());
     for (let i = 0; i < this.points.length; i++) {
-      for (const j of this.nearestVisible(this.points[i]!, this.#k, i)) {
+      // The k nearest corners of a corner in a long corridor are often all on one side. The cones add a link along the corridor.
+      for (const j of this.#nearestVisible(this.points[i]!, this.#k, i, this.#pad, options.cones ?? false)) {
         links[i]!.add(j);
         links[j]!.add(i);
       }
@@ -221,13 +227,17 @@ export class CornerGraph {
    * within `r` that an earlier ring did not test, nearest first, and equal distances by index.
    * The ring of `r` takes the corners of the buckets that the square of side `2r` around `p` touches.
    * A corner of these buckets beyond `r` waits for the next ring. So the method visits each bucket one time.
+   * With `cones`, the method also gives the nearest visible corner of each of four cones around the axes that the `k` nearest corners leave empty.
    */
-  #nearestVisible(p: Point, k: number, self: number, pad: number): number[] {
+  #nearestVisible(p: Point, k: number, self: number, pad: number, cones = false): number[] {
     const out: number[] = [];
+    // The bits of the full cones: 1 is +x, 2 is +y, 4 is -x and 8 is -y.
+    let full = 0;
     if (this.#dist.length < this.points.length) this.#dist = new Float64Array(this.points.length);
     const dd = this.#dist;
     const points = this.points;
     const cell = this.#cell;
+    const reach = CONE_CELLS * cell;
     const blockers: Node[] = [];
     const now = this.#near;
     // The corners that the rings found beyond their radius. The next ring takes them.
@@ -238,6 +248,8 @@ export class CornerGraph {
     let pj0 = 1;
     let pj1 = 0;
     for (let r = cell; r <= cell * 8; r *= 2) {
+      // The ring of `r` holds the corners beyond `r / 2`. With the k nearest corners, the cones take no corner beyond `reach`.
+      if (out.length >= k && r / 2 >= reach) return out;
       // These bounds are the bounds of a query of the box at (p.x - r, p.y - r) with the side 2r.
       const x0 = p.x - r;
       const y0 = p.y - r;
@@ -273,6 +285,12 @@ export class CornerGraph {
         // A node that stopped an earlier segment often stops this segment too, so the test takes these nodes first.
         // The order of the nodes does not change the result.
         const q = points[j]!;
+        const cone = cones ? coneOf(q.x - p.x, q.y - p.y) : 0;
+        if (out.length >= k) {
+          // After the k nearest corners, only a corner of an empty cone counts, up to `CONE_CELLS` cells from `p`.
+          if (dd[j]! > reach) return out;
+          if ((full & cone) !== 0) continue;
+        }
         let blocked = false;
         for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits(p, q, blockers[b]!, pad);
         if (blocked) continue;
@@ -280,7 +298,8 @@ export class CornerGraph {
         if (hit !== undefined) blockers.push(hit);
         else {
           out.push(j);
-          if (out.length >= k) return out;
+          full |= cone;
+          if (out.length >= k && (!cones || full === 15)) return out;
         }
       }
       wait = later;
@@ -474,6 +493,12 @@ export class CornerGraph {
   }
 }
 
+/** A link of a cone is at most this number of cells long. A longer search costs time on a dense level and finds few new links. */
+const CONE_CELLS = 3;
+
+/** This function gives the bit of the cone of the offset (`dx`, `dy`): 1 is +x, 2 is +y, 4 is -x and 8 is -y. A diagonal offset is in a cone of the x axis. */
+const coneOf = (dx: number, dy: number): number => (Math.abs(dx) >= Math.abs(dy) ? (dx > 0 ? 1 : 4) : dy > 0 ? 2 : 8);
+
 /** This function packs the two indices of a bucket into one number. Each index stays within ±2^20. */
 const bucketKey = (i: number, j: number): number => (i + 1_048_576) * 2_097_152 + (j + 1_048_576);